source3/libsmb/libsmb_xattr.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-2008
   9    Copyright (C) Jeremy Allison 2007, 2008
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 3 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  23 */
  24
  25 #include "includes.h"
  26 #include "libsmbclient.h"
  27 #include "libsmb_internal.h"
  28
  29
  30 /*
  31  * Find an lsa pipe handle associated with a cli struct.
  32  */
  33 static struct rpc_pipe_client *
  34 find_lsa_pipe_hnd(struct cli_state *ipc_cli)
  35 {
  36         struct rpc_pipe_client *pipe_hnd;
  37
  38         for (pipe_hnd = ipc_cli->pipe_list;
  39              pipe_hnd;
  40              pipe_hnd = pipe_hnd->next) {
  41                 if (ndr_syntax_id_equal(&pipe_hnd->abstract_syntax,
  42                                         &ndr_table_lsarpc.syntax_id)) {
  43                         return pipe_hnd;
  44                 }
  45         }
  46         return NULL;
  47 }
  48
  49 /*
  50  * Sort ACEs according to the documentation at
  51  * http://support.microsoft.com/kb/269175, at least as far as it defines the
  52  * order.
  53  */
  54
  55 static int
  56 ace_compare(SEC_ACE *ace1,
  57             SEC_ACE *ace2)
  58 {
  59         bool b1;
  60         bool b2;
  61
  62         /* If the ACEs are equal, we have nothing more to do. */
  63         if (sec_ace_equal(ace1, ace2)) {
  64                 return 0;
  65         }
  66
  67         /* Inherited follow non-inherited */
  68         b1 = ((ace1->flags & SEC_ACE_FLAG_INHERITED_ACE) != 0);
  69         b2 = ((ace2->flags & SEC_ACE_FLAG_INHERITED_ACE) != 0);
  70         if (b1 != b2) {
  71                 return (b1 ? 1 : -1);
  72         }
  73
  74         /*
  75          * What shall we do with AUDITs and ALARMs?  It's undefined.  We'll
  76          * sort them after DENY and ALLOW.
  77          */
  78         b1 = (ace1->type != SEC_ACE_TYPE_ACCESS_ALLOWED &&
  79               ace1->type != SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT &&
  80               ace1->type != SEC_ACE_TYPE_ACCESS_DENIED &&
  81               ace1->type != SEC_ACE_TYPE_ACCESS_DENIED_OBJECT);
  82         b2 = (ace2->type != SEC_ACE_TYPE_ACCESS_ALLOWED &&
  83               ace2->type != SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT &&
  84               ace2->type != SEC_ACE_TYPE_ACCESS_DENIED &&
  85               ace2->type != SEC_ACE_TYPE_ACCESS_DENIED_OBJECT);
  86         if (b1 != b2) {
  87                 return (b1 ? 1 : -1);
  88         }
  89
  90         /* Allowed ACEs follow denied ACEs */
  91         b1 = (ace1->type == SEC_ACE_TYPE_ACCESS_ALLOWED ||
  92               ace1->type == SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT);
  93         b2 = (ace2->type == SEC_ACE_TYPE_ACCESS_ALLOWED ||
  94               ace2->type == SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT);
  95         if (b1 != b2) {
  96                 return (b1 ? 1 : -1);
  97         }
  98
  99         /*
 100          * ACEs applying to an entity's object follow those applying to the
 101          * entity itself
 102          */
 103         b1 = (ace1->type == SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT ||
 104               ace1->type == SEC_ACE_TYPE_ACCESS_DENIED_OBJECT);
 105         b2 = (ace2->type == SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT ||
 106               ace2->type == SEC_ACE_TYPE_ACCESS_DENIED_OBJECT);
 107         if (b1 != b2) {
 108                 return (b1 ? 1 : -1);
 109         }
 110
 111         /*
 112          * If we get this far, the ACEs are similar as far as the
 113          * characteristics we typically care about (those defined by the
 114          * referenced MS document).  We'll now sort by characteristics that
 115          * just seems reasonable.
 116          */
 117
 118         if (ace1->type != ace2->type) {
 119                 return ace2->type - ace1->type;
 120         }
 121
 122         if (sid_compare(&ace1->trustee, &ace2->trustee)) {
 123                 return sid_compare(&ace1->trustee, &ace2->trustee);
 124         }
 125
 126         if (ace1->flags != ace2->flags) {
 127                 return ace1->flags - ace2->flags;
 128         }
 129
 130         if (ace1->access_mask != ace2->access_mask) {
 131                 return ace1->access_mask - ace2->access_mask;
 132         }
 133
 134         if (ace1->size != ace2->size) {
 135                 return ace1->size - ace2->size;
 136         }
 137
 138         return memcmp(ace1, ace2, sizeof(SEC_ACE));
 139 }
 140
 141
 142 static void
 143 sort_acl(SEC_ACL *the_acl)
 144 {
 145         uint32 i;
 146         if (!the_acl) return;
 147
 148         TYPESAFE_QSORT(the_acl->aces, the_acl->num_aces, ace_compare);
 149
 150         for (i=1;i<the_acl->num_aces;) {
 151                 if (sec_ace_equal(&the_acl->aces[i-1], &the_acl->aces[i])) {
 152                         int j;
 153                         for (j=i; j<the_acl->num_aces-1; j++) {
 154                                 the_acl->aces[j] = the_acl->aces[j+1];
 155                         }
 156                         the_acl->num_aces--;
 157                 } else {
 158                         i++;
 159                 }
 160         }
 161 }
 162
 163 /* convert a SID to a string, either numeric or username/group */
 164 static void
 165 convert_sid_to_string(struct cli_state *ipc_cli,
 166                       struct policy_handle *pol,
 167                       fstring str,
 168                       bool numeric,
 169                       DOM_SID *sid)
 170 {
 171         char **domains = NULL;
 172         char **names = NULL;
 173         enum lsa_SidType *types = NULL;
 174         struct rpc_pipe_client *pipe_hnd = find_lsa_pipe_hnd(ipc_cli);
 175         TALLOC_CTX *ctx;
 176
 177         sid_to_fstring(str, sid);
 178
 179         if (numeric) {
 180                 return;     /* no lookup desired */
 181         }
 182
 183         if (!pipe_hnd) {
 184                 return;
 185         }
 186
 187         /* Ask LSA to convert the sid to a name */
 188
 189         ctx = talloc_stackframe();
 190
 191         if (!NT_STATUS_IS_OK(rpccli_lsa_lookup_sids(pipe_hnd, ctx,
 192                                                     pol, 1, sid, &domains,
 193                                                     &names, &types)) ||
 194             !domains || !domains[0] || !names || !names[0]) {
 195                 TALLOC_FREE(ctx);
 196                 return;
 197         }
 198
 199         /* Converted OK */
 200
 201         slprintf(str, sizeof(fstring) - 1, "%s%s%s",
 202                  domains[0], lp_winbind_separator(),
 203                  names[0]);
 204
 205         TALLOC_FREE(ctx);
 206 }
 207
 208 /* convert a string to a SID, either numeric or username/group */
 209 static bool
 210 convert_string_to_sid(struct cli_state *ipc_cli,
 211                       struct policy_handle *pol,
 212                       bool numeric,
 213                       DOM_SID *sid,
 214                       const char *str)
 215 {
 216         enum lsa_SidType *types = NULL;
 217         DOM_SID *sids = NULL;
 218         bool result = True;
 219         TALLOC_CTX *ctx = NULL;
 220         struct rpc_pipe_client *pipe_hnd = find_lsa_pipe_hnd(ipc_cli);
 221
 222         if (!pipe_hnd) {
 223                 return False;
 224         }
 225
 226         if (numeric) {
 227                 if (strncmp(str, "S-", 2) == 0) {
 228                         return string_to_sid(sid, str);
 229                 }
 230
 231                 result = False;
 232                 goto done;
 233         }
 234
 235         ctx = talloc_stackframe();
 236         if (!NT_STATUS_IS_OK(rpccli_lsa_lookup_names(pipe_hnd, ctx,
 237                                                      pol, 1, &str,
 238                                                      NULL, 1, &sids,
 239                                                      &types))) {
 240                 result = False;
 241                 goto done;
 242         }
 243
 244         sid_copy(sid, &sids[0]);
 245 done:
 246         TALLOC_FREE(ctx);
 247         return result;
 248 }
 249
 250
 251 /* parse an ACE in the same format as print_ace() */
 252 static bool
 253 parse_ace(struct cli_state *ipc_cli,
 254           struct policy_handle *pol,
 255           SEC_ACE *ace,
 256           bool numeric,
 257           char *str)
 258 {
 259         char *p;
 260         const char *cp;
 261         char *tok;
 262         unsigned int atype;
 263         unsigned int aflags;
 264         unsigned int amask;
 265         DOM_SID sid;
 266         uint32_t mask;
 267         const struct perm_value *v;
 268         struct perm_value {
 269                 const char perm[7];
 270                 uint32 mask;
 271         };
 272         TALLOC_CTX *frame = talloc_stackframe();
 273
 274         /* These values discovered by inspection */
 275         static const struct perm_value special_values[] = {
 276                 { "R", 0x00120089 },
 277                 { "W", 0x00120116 },
 278                 { "X", 0x001200a0 },
 279                 { "D", 0x00010000 },
 280                 { "P", 0x00040000 },
 281                 { "O", 0x00080000 },
 282                 { "", 0 },
 283         };
 284
 285         static const struct perm_value standard_values[] = {
 286                 { "READ",   0x001200a9 },
 287                 { "CHANGE", 0x001301bf },
 288                 { "FULL",   0x001f01ff },
 289                 { "", 0 },
 290         };
 291
 292         ZERO_STRUCTP(ace);
 293         p = strchr_m(str,':');
 294         if (!p) {
 295                 TALLOC_FREE(frame);
 296                 return False;
 297         }
 298         *p = '\0';
 299         p++;
 300         /* Try to parse numeric form */
 301
 302         if (sscanf(p, "%i/%i/%i", &atype, &aflags, &amask) == 3 &&
 303             convert_string_to_sid(ipc_cli, pol, numeric, &sid, str)) {
 304                 goto done;
 305         }
 306
 307         /* Try to parse text form */
 308
 309         if (!convert_string_to_sid(ipc_cli, pol, numeric, &sid, str)) {
 310                 TALLOC_FREE(frame);
 311                 return false;
 312         }
 313
 314         cp = p;
 315         if (!next_token_talloc(frame, &cp, &tok, "/")) {
 316                 TALLOC_FREE(frame);
 317                 return false;
 318         }
 319
 320         if (StrnCaseCmp(tok, "ALLOWED", strlen("ALLOWED")) == 0) {
 321                 atype = SEC_ACE_TYPE_ACCESS_ALLOWED;
 322         } else if (StrnCaseCmp(tok, "DENIED", strlen("DENIED")) == 0) {
 323                 atype = SEC_ACE_TYPE_ACCESS_DENIED;
 324         } else {
 325                 TALLOC_FREE(frame);
 326                 return false;
 327         }
 328
 329         /* Only numeric form accepted for flags at present */
 330
 331         if (!(next_token_talloc(frame, &cp, &tok, "/") &&
 332               sscanf(tok, "%i", &aflags))) {
 333                 TALLOC_FREE(frame);
 334                 return false;
 335         }
 336
 337         if (!next_token_talloc(frame, &cp, &tok, "/")) {
 338                 TALLOC_FREE(frame);
 339                 return false;
 340         }
 341
 342         if (strncmp(tok, "0x", 2) == 0) {
 343                 if (sscanf(tok, "%i", &amask) != 1) {
 344                         TALLOC_FREE(frame);
 345                         return false;
 346                 }
 347                 goto done;
 348         }
 349
 350         for (v = standard_values; v->perm; v++) {
 351                 if (strcmp(tok, v->perm) == 0) {
 352                         amask = v->mask;
 353                         goto done;
 354                 }
 355         }
 356
 357         p = tok;
 358
 359         while(*p) {
 360                 bool found = False;
 361
 362                 for (v = special_values; v->perm; v++) {
 363                         if (v->perm[0] == *p) {
 364                                 amask |= v->mask;
 365                                 found = True;
 366                         }
 367                 }
 368
 369                 if (!found) {
 370                         TALLOC_FREE(frame);
 371                         return false;
 372                 }
 373                 p++;
 374         }
 375
 376         if (*p) {
 377                 TALLOC_FREE(frame);
 378                 return false;
 379         }
 380
 381 done:
 382         mask = amask;
 383         init_sec_ace(ace, &sid, atype, mask, aflags);
 384         TALLOC_FREE(frame);
 385         return true;
 386 }
 387
 388 /* add an ACE to a list of ACEs in a SEC_ACL */
 389 static bool
 390 add_ace(SEC_ACL **the_acl,
 391         SEC_ACE *ace,
 392         TALLOC_CTX *ctx)
 393 {
 394         SEC_ACL *newacl;
 395         SEC_ACE *aces;
 396
 397         if (! *the_acl) {
 398                 (*the_acl) = make_sec_acl(ctx, 3, 1, ace);
 399                 return True;
 400         }
 401
 402         if ((aces = SMB_CALLOC_ARRAY(SEC_ACE,
 403                                      1+(*the_acl)->num_aces)) == NULL) {
 404                 return False;
 405         }
 406         memcpy(aces, (*the_acl)->aces, (*the_acl)->num_aces * sizeof(SEC_ACE));
 407         memcpy(aces+(*the_acl)->num_aces, ace, sizeof(SEC_ACE));
 408         newacl = make_sec_acl(ctx, (*the_acl)->revision,
 409                               1+(*the_acl)->num_aces, aces);
 410         SAFE_FREE(aces);
 411         (*the_acl) = newacl;
 412         return True;
 413 }
 414
 415
 416 /* parse a ascii version of a security descriptor */
 417 static SEC_DESC *
 418 sec_desc_parse(TALLOC_CTX *ctx,
 419                struct cli_state *ipc_cli,
 420                struct policy_handle *pol,
 421                bool numeric,
 422                const char *str)
 423 {
 424         const char *p = str;
 425         char *tok;
 426         SEC_DESC *ret = NULL;
 427         size_t sd_size;
 428         DOM_SID *group_sid=NULL;
 429         DOM_SID *owner_sid=NULL;
 430         SEC_ACL *dacl=NULL;
 431         int revision=1;
 432
 433         while (next_token_talloc(ctx, &p, &tok, "\t,\r\n")) {
 434
 435                 if (StrnCaseCmp(tok,"REVISION:", 9) == 0) {
 436                         revision = strtol(tok+9, NULL, 16);
 437                         continue;
 438                 }
 439
 440                 if (StrnCaseCmp(tok,"OWNER:", 6) == 0) {
 441                         if (owner_sid) {
 442                                 DEBUG(5,("OWNER specified more than once!\n"));
 443                                 goto done;
 444                         }
 445                         owner_sid = SMB_CALLOC_ARRAY(DOM_SID, 1);
 446                         if (!owner_sid ||
 447                             !convert_string_to_sid(ipc_cli, pol,
 448                                                    numeric,
 449                                                    owner_sid, tok+6)) {
 450                                 DEBUG(5, ("Failed to parse owner sid\n"));
 451                                 goto done;
 452                         }
 453                         continue;
 454                 }
 455
 456                 if (StrnCaseCmp(tok,"OWNER+:", 7) == 0) {
 457                         if (owner_sid) {
 458                                 DEBUG(5,("OWNER specified more than once!\n"));
 459                                 goto done;
 460                         }
 461                         owner_sid = SMB_CALLOC_ARRAY(DOM_SID, 1);
 462                         if (!owner_sid ||
 463                             !convert_string_to_sid(ipc_cli, pol,
 464                                                    False,
 465                                                    owner_sid, tok+7)) {
 466                                 DEBUG(5, ("Failed to parse owner sid\n"));
 467                                 goto done;
 468                         }
 469                         continue;
 470                 }
 471
 472                 if (StrnCaseCmp(tok,"GROUP:", 6) == 0) {
 473                         if (group_sid) {
 474                                 DEBUG(5,("GROUP specified more than once!\n"));
 475                                 goto done;
 476                         }
 477                         group_sid = SMB_CALLOC_ARRAY(DOM_SID, 1);
 478                         if (!group_sid ||
 479                             !convert_string_to_sid(ipc_cli, pol,
 480                                                    numeric,
 481                                                    group_sid, tok+6)) {
 482                                 DEBUG(5, ("Failed to parse group sid\n"));
 483                                 goto done;
 484                         }
 485                         continue;
 486                 }
 487
 488                 if (StrnCaseCmp(tok,"GROUP+:", 7) == 0) {
 489                         if (group_sid) {
 490                                 DEBUG(5,("GROUP specified more than once!\n"));
 491                                 goto done;
 492                         }
 493                         group_sid = SMB_CALLOC_ARRAY(DOM_SID, 1);
 494                         if (!group_sid ||
 495                             !convert_string_to_sid(ipc_cli, pol,
 496                                                    False,
 497                                                    group_sid, tok+6)) {
 498                                 DEBUG(5, ("Failed to parse group sid\n"));
 499                                 goto done;
 500                         }
 501                         continue;
 502                 }
 503
 504                 if (StrnCaseCmp(tok,"ACL:", 4) == 0) {
 505                         SEC_ACE ace;
 506                         if (!parse_ace(ipc_cli, pol, &ace, numeric, tok+4)) {
 507                                 DEBUG(5, ("Failed to parse ACL %s\n", tok));
 508                                 goto done;
 509                         }
 510                         if(!add_ace(&dacl, &ace, ctx)) {
 511                                 DEBUG(5, ("Failed to add ACL %s\n", tok));
 512                                 goto done;
 513                         }
 514                         continue;
 515                 }
 516
 517                 if (StrnCaseCmp(tok,"ACL+:", 5) == 0) {
 518                         SEC_ACE ace;
 519                         if (!parse_ace(ipc_cli, pol, &ace, False, tok+5)) {
 520                                 DEBUG(5, ("Failed to parse ACL %s\n", tok));
 521                                 goto done;
 522                         }
 523                         if(!add_ace(&dacl, &ace, ctx)) {
 524                                 DEBUG(5, ("Failed to add ACL %s\n", tok));
 525                                 goto done;
 526                         }
 527                         continue;
 528                 }
 529
 530                 DEBUG(5, ("Failed to parse security descriptor\n"));
 531                 goto done;
 532         }
 533
 534         ret = make_sec_desc(ctx, revision, SEC_DESC_SELF_RELATIVE,
 535                             owner_sid, group_sid, NULL, dacl, &sd_size);
 536
 537 done:
 538         SAFE_FREE(group_sid);
 539         SAFE_FREE(owner_sid);
 540         return ret;
 541 }
 542
 543
 544 /* Obtain the current dos attributes */
 545 static DOS_ATTR_DESC *
 546 dos_attr_query(SMBCCTX *context,
 547                TALLOC_CTX *ctx,
 548                const char *filename,
 549                SMBCSRV *srv)
 550 {
 551         struct timespec create_time_ts;
 552         struct timespec write_time_ts;
 553         struct timespec access_time_ts;
 554         struct timespec change_time_ts;
 555         SMB_OFF_T size = 0;
 556         uint16 mode = 0;
 557         SMB_INO_T inode = 0;
 558         DOS_ATTR_DESC *ret;
 559
 560         ret = TALLOC_P(ctx, DOS_ATTR_DESC);
 561         if (!ret) {
 562                 errno = ENOMEM;
 563                 return NULL;
 564         }
 565
 566         /* Obtain the DOS attributes */
 567         if (!SMBC_getatr(context, srv, CONST_DISCARD(char *, filename),
 568                          &mode, &size,
 569                          &create_time_ts,
 570                          &access_time_ts,
 571                          &write_time_ts,
 572                          &change_time_ts,
 573                          &inode)) {
 574                 errno = SMBC_errno(context, srv->cli);
 575                 DEBUG(5, ("dos_attr_query Failed to query old attributes\n"));
 576                 return NULL;
 577         }
 578
 579         ret->mode = mode;
 580         ret->size = size;
 581         ret->create_time = convert_timespec_to_time_t(create_time_ts);
 582         ret->access_time = convert_timespec_to_time_t(access_time_ts);
 583         ret->write_time = convert_timespec_to_time_t(write_time_ts);
 584         ret->change_time = convert_timespec_to_time_t(change_time_ts);
 585         ret->inode = inode;
 586
 587         return ret;
 588 }
 589
 590
 591 /* parse a ascii version of a security descriptor */
 592 static void
 593 dos_attr_parse(SMBCCTX *context,
 594                DOS_ATTR_DESC *dad,
 595                SMBCSRV *srv,
 596                char *str)
 597 {
 598         int n;
 599         const char *p = str;
 600         char *tok = NULL;
 601         TALLOC_CTX *frame = NULL;
 602         struct {
 603                 const char * create_time_attr;
 604                 const char * access_time_attr;
 605                 const char * write_time_attr;
 606                 const char * change_time_attr;
 607         } attr_strings;
 608
 609         /* Determine whether to use old-style or new-style attribute names */
 610         if (context->internal->full_time_names) {
 611                 /* new-style names */
 612                 attr_strings.create_time_attr = "CREATE_TIME";
 613                 attr_strings.access_time_attr = "ACCESS_TIME";
 614                 attr_strings.write_time_attr = "WRITE_TIME";
 615                 attr_strings.change_time_attr = "CHANGE_TIME";
 616         } else {
 617                 /* old-style names */
 618                 attr_strings.create_time_attr = NULL;
 619                 attr_strings.access_time_attr = "A_TIME";
 620                 attr_strings.write_time_attr = "M_TIME";
 621                 attr_strings.change_time_attr = "C_TIME";
 622         }
 623
 624         /* if this is to set the entire ACL... */
 625         if (*str == '*') {
 626                 /* ... then increment past the first colon if there is one */
 627                 if ((p = strchr(str, ':')) != NULL) {
 628                         ++p;
 629                 } else {
 630                         p = str;
 631                 }
 632         }
 633
 634         frame = talloc_stackframe();
 635         while (next_token_talloc(frame, &p, &tok, "\t,\r\n")) {
 636                 if (StrnCaseCmp(tok, "MODE:", 5) == 0) {
 637                         long request = strtol(tok+5, NULL, 16);
 638                         if (request == 0) {
 639                                 dad->mode = (request |
 640                                              (IS_DOS_DIR(dad->mode)
 641                                               ? FILE_ATTRIBUTE_DIRECTORY
 642                                               : FILE_ATTRIBUTE_NORMAL));
 643                         } else {
 644                                 dad->mode = request;
 645                         }
 646                         continue;
 647                 }
 648
 649                 if (StrnCaseCmp(tok, "SIZE:", 5) == 0) {
 650                         dad->size = (SMB_OFF_T)atof(tok+5);
 651                         continue;
 652                 }
 653
 654                 n = strlen(attr_strings.access_time_attr);
 655                 if (StrnCaseCmp(tok, attr_strings.access_time_attr, n) == 0) {
 656                         dad->access_time = (time_t)strtol(tok+n+1, NULL, 10);
 657                         continue;
 658                 }
 659
 660                 n = strlen(attr_strings.change_time_attr);
 661                 if (StrnCaseCmp(tok, attr_strings.change_time_attr, n) == 0) {
 662                         dad->change_time = (time_t)strtol(tok+n+1, NULL, 10);
 663                         continue;
 664                 }
 665
 666                 n = strlen(attr_strings.write_time_attr);
 667                 if (StrnCaseCmp(tok, attr_strings.write_time_attr, n) == 0) {
 668                         dad->write_time = (time_t)strtol(tok+n+1, NULL, 10);
 669                         continue;
 670                 }
 671
 672                 if (attr_strings.create_time_attr != NULL) {
 673                         n = strlen(attr_strings.create_time_attr);
 674                         if (StrnCaseCmp(tok, attr_strings.create_time_attr,
 675                                         n) == 0) {
 676                                 dad->create_time = (time_t)strtol(tok+n+1,
 677                                                                   NULL, 10);
 678                                 continue;
 679                         }
 680                 }
 681
 682                 if (StrnCaseCmp(tok, "INODE:", 6) == 0) {
 683                         dad->inode = (SMB_INO_T)atof(tok+6);
 684                         continue;
 685                 }
 686         }
 687         TALLOC_FREE(frame);
 688 }
 689
 690 /*****************************************************
 691  Retrieve the acls for a file.
 692 *******************************************************/
 693
 694 static int
 695 cacl_get(SMBCCTX *context,
 696          TALLOC_CTX *ctx,
 697          SMBCSRV *srv,
 698          struct cli_state *ipc_cli,
 699          struct policy_handle *pol,
 700          char *filename,
 701          char *attr_name,
 702          char *buf,
 703          int bufsize)
 704 {
 705         uint32 i;
 706         int n = 0;
 707         int n_used;
 708         bool all;
 709         bool all_nt;
 710         bool all_nt_acls;
 711         bool all_dos;
 712         bool some_nt;
 713         bool some_dos;
 714         bool exclude_nt_revision = False;
 715         bool exclude_nt_owner = False;
 716         bool exclude_nt_group = False;
 717         bool exclude_nt_acl = False;
 718         bool exclude_dos_mode = False;
 719         bool exclude_dos_size = False;
 720         bool exclude_dos_create_time = False;
 721         bool exclude_dos_access_time = False;
 722         bool exclude_dos_write_time = False;
 723         bool exclude_dos_change_time = False;
 724         bool exclude_dos_inode = False;
 725         bool numeric = True;
 726         bool determine_size = (bufsize == 0);
 727         uint16_t fnum;
 728         SEC_DESC *sd;
 729         fstring sidstr;
 730         fstring name_sandbox;
 731         char *name;
 732         char *pExclude;
 733         char *p;
 734         struct timespec create_time_ts;
 735         struct timespec write_time_ts;
 736         struct timespec access_time_ts;
 737         struct timespec change_time_ts;
 738         time_t create_time = (time_t)0;
 739         time_t write_time = (time_t)0;
 740         time_t access_time = (time_t)0;
 741         time_t change_time = (time_t)0;
 742         SMB_OFF_T size = 0;
 743         uint16 mode = 0;
 744         SMB_INO_T ino = 0;
 745         struct cli_state *cli = srv->cli;
 746         struct {
 747                 const char * create_time_attr;
 748                 const char * access_time_attr;
 749                 const char * write_time_attr;
 750                 const char * change_time_attr;
 751         } attr_strings;
 752         struct {
 753                 const char * create_time_attr;
 754                 const char * access_time_attr;
 755                 const char * write_time_attr;
 756                 const char * change_time_attr;
 757         } excl_attr_strings;
 758
 759         /* Determine whether to use old-style or new-style attribute names */
 760         if (context->internal->full_time_names) {
 761                 /* new-style names */
 762                 attr_strings.create_time_attr = "CREATE_TIME";
 763                 attr_strings.access_time_attr = "ACCESS_TIME";
 764                 attr_strings.write_time_attr = "WRITE_TIME";
 765                 attr_strings.change_time_attr = "CHANGE_TIME";
 766
 767                 excl_attr_strings.create_time_attr = "CREATE_TIME";
 768                 excl_attr_strings.access_time_attr = "ACCESS_TIME";
 769                 excl_attr_strings.write_time_attr = "WRITE_TIME";
 770                 excl_attr_strings.change_time_attr = "CHANGE_TIME";
 771         } else {
 772                 /* old-style names */
 773                 attr_strings.create_time_attr = NULL;
 774                 attr_strings.access_time_attr = "A_TIME";
 775                 attr_strings.write_time_attr = "M_TIME";
 776                 attr_strings.change_time_attr = "C_TIME";
 777
 778                 excl_attr_strings.create_time_attr = NULL;
 779                 excl_attr_strings.access_time_attr = "dos_attr.A_TIME";
 780                 excl_attr_strings.write_time_attr = "dos_attr.M_TIME";
 781                 excl_attr_strings.change_time_attr = "dos_attr.C_TIME";
 782         }
 783
 784         /* Copy name so we can strip off exclusions (if any are specified) */
 785         strncpy(name_sandbox, attr_name, sizeof(name_sandbox) - 1);
 786
 787         /* Ensure name is null terminated */
 788         name_sandbox[sizeof(name_sandbox) - 1] = '\0';
 789
 790         /* Play in the sandbox */
 791         name = name_sandbox;
 792
 793         /* If there are any exclusions, point to them and mask them from name */
 794         if ((pExclude = strchr(name, '!')) != NULL)
 795         {
 796                 *pExclude++ = '\0';
 797         }
 798
 799         all = (StrnCaseCmp(name, "system.*", 8) == 0);
 800         all_nt = (StrnCaseCmp(name, "system.nt_sec_desc.*", 20) == 0);
 801         all_nt_acls = (StrnCaseCmp(name, "system.nt_sec_desc.acl.*", 24) == 0);
 802         all_dos = (StrnCaseCmp(name, "system.dos_attr.*", 17) == 0);
 803         some_nt = (StrnCaseCmp(name, "system.nt_sec_desc.", 19) == 0);
 804         some_dos = (StrnCaseCmp(name, "system.dos_attr.", 16) == 0);
 805         numeric = (* (name + strlen(name) - 1) != '+');
 806
 807         /* Look for exclusions from "all" requests */
 808         if (all || all_nt || all_dos) {
 809                 /* Exclusions are delimited by '!' */
 810                 for (;
 811                      pExclude != NULL;
 812                      pExclude = (p == NULL ? NULL : p + 1)) {
 813
 814                         /* Find end of this exclusion name */
 815                         if ((p = strchr(pExclude, '!')) != NULL)
 816                         {
 817                                 *p = '\0';
 818                         }
 819
 820                         /* Which exclusion name is this? */
 821                         if (StrCaseCmp(pExclude,
 822                                        "nt_sec_desc.revision") == 0) {
 823                                 exclude_nt_revision = True;
 824                         }
 825                         else if (StrCaseCmp(pExclude,
 826                                             "nt_sec_desc.owner") == 0) {
 827                                 exclude_nt_owner = True;
 828                         }
 829                         else if (StrCaseCmp(pExclude,
 830                                             "nt_sec_desc.group") == 0) {
 831                                 exclude_nt_group = True;
 832                         }
 833                         else if (StrCaseCmp(pExclude,
 834                                             "nt_sec_desc.acl") == 0) {
 835                                 exclude_nt_acl = True;
 836                         }
 837                         else if (StrCaseCmp(pExclude,
 838                                             "dos_attr.mode") == 0) {
 839                                 exclude_dos_mode = True;
 840                         }
 841                         else if (StrCaseCmp(pExclude,
 842                                             "dos_attr.size") == 0) {
 843                                 exclude_dos_size = True;
 844                         }
 845                         else if (excl_attr_strings.create_time_attr != NULL &&
 846                                  StrCaseCmp(pExclude,
 847                                             excl_attr_strings.change_time_attr) == 0) {
 848                                 exclude_dos_create_time = True;
 849                         }
 850                         else if (StrCaseCmp(pExclude,
 851                                             excl_attr_strings.access_time_attr) == 0) {
 852                                 exclude_dos_access_time = True;
 853                         }
 854                         else if (StrCaseCmp(pExclude,
 855                                             excl_attr_strings.write_time_attr) == 0) {
 856                                 exclude_dos_write_time = True;
 857                         }
 858                         else if (StrCaseCmp(pExclude,
 859                                             excl_attr_strings.change_time_attr) == 0) {
 860                                 exclude_dos_change_time = True;
 861                         }
 862                         else if (StrCaseCmp(pExclude, "dos_attr.inode") == 0) {
 863                                 exclude_dos_inode = True;
 864                         }
 865                         else {
 866                                 DEBUG(5, ("cacl_get received unknown exclusion: %s\n",
 867                                           pExclude));
 868                                 errno = ENOATTR;
 869                                 return -1;
 870                         }
 871                 }
 872         }
 873
 874         n_used = 0;
 875
 876         /*
 877          * If we are (possibly) talking to an NT or new system and some NT
 878          * attributes have been requested...
 879          */
 880         if (ipc_cli && (all || some_nt || all_nt_acls)) {
 881                 char *targetpath = NULL;
 882                 struct cli_state *targetcli = NULL;
 883
 884                 /* Point to the portion after "system.nt_sec_desc." */
 885                 name += 19;     /* if (all) this will be invalid but unused */
 886
 887                 if (!cli_resolve_path(ctx, "", context->internal->auth_info,
 888                                 cli, filename,
 889                                 &targetcli, &targetpath)) {
 890                         DEBUG(5, ("cacl_get Could not resolve %s\n",
 891                                 filename));
 892                         errno = ENOENT;
 893                         return -1;
 894                 }
 895
 896                 /* ... then obtain any NT attributes which were requested */
 897                 if (!NT_STATUS_IS_OK(cli_ntcreate(targetcli, targetpath, 0, CREATE_ACCESS_READ, 0,
 898                                 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN, 0x0, 0x0, &fnum))) {
 899                         DEBUG(5, ("cacl_get failed to open %s: %s\n",
 900                                 targetpath, cli_errstr(targetcli)));
 901                         errno = 0;
 902                         return -1;
 903                 }
 904
 905                 sd = cli_query_secdesc(targetcli, fnum, ctx);
 906
 907                 if (!sd) {
 908                         DEBUG(5,
 909                               ("cacl_get Failed to query old descriptor\n"));
 910                         errno = 0;
 911                         return -1;
 912                 }
 913
 914                 cli_close(targetcli, fnum);
 915
 916                 if (! exclude_nt_revision) {
 917                         if (all || all_nt) {
 918                                 if (determine_size) {
 919                                         p = talloc_asprintf(ctx,
 920                                                             "REVISION:%d",
 921                                                             sd->revision);
 922                                         if (!p) {
 923                                                 errno = ENOMEM;
 924                                                 return -1;
 925                                         }
 926                                         n = strlen(p);
 927                                 } else {
 928                                         n = snprintf(buf, bufsize,
 929                                                      "REVISION:%d",
 930                                                      sd->revision);
 931                                 }
 932                         } else if (StrCaseCmp(name, "revision") == 0) {
 933                                 if (determine_size) {
 934                                         p = talloc_asprintf(ctx, "%d",
 935                                                             sd->revision);
 936                                         if (!p) {
 937                                                 errno = ENOMEM;
 938                                                 return -1;
 939                                         }
 940                                         n = strlen(p);
 941                                 } else {
 942                                         n = snprintf(buf, bufsize, "%d",
 943                                                      sd->revision);
 944                                 }
 945                         }
 946
 947                         if (!determine_size && n > bufsize) {
 948                                 errno = ERANGE;
 949                                 return -1;
 950                         }
 951                         buf += n;
 952                         n_used += n;
 953                         bufsize -= n;
 954                         n = 0;
 955                 }
 956
 957                 if (! exclude_nt_owner) {
 958                         /* Get owner and group sid */
 959                         if (sd->owner_sid) {
 960                                 convert_sid_to_string(ipc_cli, pol,
 961                                                       sidstr,
 962                                                       numeric,
 963                                                       sd->owner_sid);
 964                         } else {
 965                                 fstrcpy(sidstr, "");
 966                         }
 967
 968                         if (all || all_nt) {
 969                                 if (determine_size) {
 970                                         p = talloc_asprintf(ctx, ",OWNER:%s",
 971                                                             sidstr);
 972                                         if (!p) {
 973                                                 errno = ENOMEM;
 974                                                 return -1;
 975                                         }
 976                                         n = strlen(p);
 977                                 } else if (sidstr[0] != '\0') {
 978                                         n = snprintf(buf, bufsize,
 979                                                      ",OWNER:%s", sidstr);
 980                                 }
 981                         } else if (StrnCaseCmp(name, "owner", 5) == 0) {
 982                                 if (determine_size) {
 983                                         p = talloc_asprintf(ctx, "%s", sidstr);
 984                                         if (!p) {
 985                                                 errno = ENOMEM;
 986                                                 return -1;
 987                                         }
 988                                         n = strlen(p);
 989                                 } else {
 990                                         n = snprintf(buf, bufsize, "%s",
 991                                                      sidstr);
 992                                 }
 993                         }
 994
 995                         if (!determine_size && n > bufsize) {
 996                                 errno = ERANGE;
 997                                 return -1;
 998                         }
 999                         buf += n;
1000                         n_used += n;
1001                         bufsize -= n;
1002                         n = 0;
1003                 }
1004
1005                 if (! exclude_nt_group) {
1006                         if (sd->group_sid) {
1007                                 convert_sid_to_string(ipc_cli, pol,
1008                                                       sidstr, numeric,
1009                                                       sd->group_sid);
1010                         } else {
1011                                 fstrcpy(sidstr, "");
1012                         }
1013
1014                         if (all || all_nt) {
1015                                 if (determine_size) {
1016                                         p = talloc_asprintf(ctx, ",GROUP:%s",
1017                                                             sidstr);
1018                                         if (!p) {
1019                                                 errno = ENOMEM;
1020                                                 return -1;
1021                                         }
1022                                         n = strlen(p);
1023                                 } else if (sidstr[0] != '\0') {
1024                                         n = snprintf(buf, bufsize,
1025                                                      ",GROUP:%s", sidstr);
1026                                 }
1027                         } else if (StrnCaseCmp(name, "group", 5) == 0) {
1028                                 if (determine_size) {
1029                                         p = talloc_asprintf(ctx, "%s", sidstr);
1030                                         if (!p) {
1031                                                 errno = ENOMEM;
1032                                                 return -1;
1033                                         }
1034                                         n = strlen(p);
1035                                 } else {
1036                                         n = snprintf(buf, bufsize,
1037                                                      "%s", sidstr);
1038                                 }
1039                         }
1040
1041                         if (!determine_size && n > bufsize) {
1042                                 errno = ERANGE;
1043                                 return -1;
1044                         }
1045                         buf += n;
1046                         n_used += n;
1047                         bufsize -= n;
1048                         n = 0;
1049                 }
1050
1051                 if (! exclude_nt_acl) {
1052                         /* Add aces to value buffer  */
1053                         for (i = 0; sd->dacl && i < sd->dacl->num_aces; i++) {
1054
1055                                 SEC_ACE *ace = &sd->dacl->aces[i];
1056                                 convert_sid_to_string(ipc_cli, pol,
1057                                                       sidstr, numeric,
1058                                                       &ace->trustee);
1059
1060                                 if (all || all_nt) {
1061                                         if (determine_size) {
1062                                                 p = talloc_asprintf(
1063                                                         ctx,
1064                                                         ",ACL:"
1065                                                         "%s:%d/%d/0x%08x",
1066                                                         sidstr,
1067                                                         ace->type,
1068                                                         ace->flags,
1069                                                         ace->access_mask);
1070                                                 if (!p) {
1071                                                         errno = ENOMEM;
1072                                                         return -1;
1073                                                 }
1074                                                 n = strlen(p);
1075                                         } else {
1076                                                 n = snprintf(
1077                                                         buf, bufsize,
1078                                                         ",ACL:%s:%d/%d/0x%08x",
1079                                                         sidstr,
1080                                                         ace->type,
1081                                                         ace->flags,
1082                                                         ace->access_mask);
1083                                         }
1084                                 } else if ((StrnCaseCmp(name, "acl", 3) == 0 &&
1085                                             StrCaseCmp(name+3, sidstr) == 0) ||
1086                                            (StrnCaseCmp(name, "acl+", 4) == 0 &&
1087                                             StrCaseCmp(name+4, sidstr) == 0)) {
1088                                         if (determine_size) {
1089                                                 p = talloc_asprintf(
1090                                                         ctx,
1091                                                         "%d/%d/0x%08x",
1092                                                         ace->type,
1093                                                         ace->flags,
1094                                                         ace->access_mask);
1095                                                 if (!p) {
1096                                                         errno = ENOMEM;
1097                                                         return -1;
1098                                                 }
1099                                                 n = strlen(p);
1100                                         } else {
1101                                                 n = snprintf(buf, bufsize,
1102                                                              "%d/%d/0x%08x",
1103                                                              ace->type,
1104                                                              ace->flags,
1105                                                              ace->access_mask);
1106                                         }
1107                                 } else if (all_nt_acls) {
1108                                         if (determine_size) {
1109                                                 p = talloc_asprintf(
1110                                                         ctx,
1111                                                         "%s%s:%d/%d/0x%08x",
1112                                                         i ? "," : "",
1113                                                         sidstr,
1114                                                         ace->type,
1115                                                         ace->flags,
1116                                                         ace->access_mask);
1117                                                 if (!p) {
1118                                                         errno = ENOMEM;
1119                                                         return -1;
1120                                                 }
1121                                                 n = strlen(p);
1122                                         } else {
1123                                                 n = snprintf(buf, bufsize,
1124                                                              "%s%s:%d/%d/0x%08x",
1125                                                              i ? "," : "",
1126                                                              sidstr,
1127                                                              ace->type,
1128                                                              ace->flags,
1129                                                              ace->access_mask);
1130                                         }
1131                                 }
1132                                 if (!determine_size && n > bufsize) {
1133                                         errno = ERANGE;
1134                                         return -1;
1135                                 }
1136                                 buf += n;
1137                                 n_used += n;
1138                                 bufsize -= n;
1139                                 n = 0;
1140                         }
1141                 }
1142
1143                 /* Restore name pointer to its original value */
1144                 name -= 19;
1145         }
1146
1147         if (all || some_dos) {
1148                 /* Point to the portion after "system.dos_attr." */
1149                 name += 16;     /* if (all) this will be invalid but unused */
1150
1151                 /* Obtain the DOS attributes */
1152                 if (!SMBC_getatr(context, srv, filename, &mode, &size,
1153                                  &create_time_ts,
1154                                  &access_time_ts,
1155                                  &write_time_ts,
1156                                  &change_time_ts,
1157                                  &ino)) {
1158
1159                         errno = SMBC_errno(context, srv->cli);
1160                         return -1;
1161                 }
1162
1163                 create_time = convert_timespec_to_time_t(create_time_ts);
1164                 access_time = convert_timespec_to_time_t(access_time_ts);
1165                 write_time = convert_timespec_to_time_t(write_time_ts);
1166                 change_time = convert_timespec_to_time_t(change_time_ts);
1167
1168                 if (! exclude_dos_mode) {
1169                         if (all || all_dos) {
1170                                 if (determine_size) {
1171                                         p = talloc_asprintf(ctx,
1172                                                             "%sMODE:0x%x",
1173                                                             (ipc_cli &&
1174                                                              (all || some_nt)
1175                                                              ? ","
1176                                                              : ""),
1177                                                             mode);
1178                                         if (!p) {
1179                                                 errno = ENOMEM;
1180                                                 return -1;
1181                                         }
1182                                         n = strlen(p);
1183                                 } else {
1184                                         n = snprintf(buf, bufsize,
1185                                                      "%sMODE:0x%x",
1186                                                      (ipc_cli &&
1187                                                       (all || some_nt)
1188                                                       ? ","
1189                                                       : ""),
1190                                                      mode);
1191                                 }
1192                         } else if (StrCaseCmp(name, "mode") == 0) {
1193                                 if (determine_size) {
1194                                         p = talloc_asprintf(ctx, "0x%x", mode);
1195                                         if (!p) {
1196                                                 errno = ENOMEM;
1197                                                 return -1;
1198                                         }
1199                                         n = strlen(p);
1200                                 } else {
1201                                         n = snprintf(buf, bufsize,
1202                                                      "0x%x", mode);
1203                                 }
1204                         }
1205
1206                         if (!determine_size && n > bufsize) {
1207                                 errno = ERANGE;
1208                                 return -1;
1209                         }
1210                         buf += n;
1211                         n_used += n;
1212                         bufsize -= n;
1213                         n = 0;
1214                 }
1215
1216                 if (! exclude_dos_size) {
1217                         if (all || all_dos) {
1218                                 if (determine_size) {
1219                                         p = talloc_asprintf(
1220                                                 ctx,
1221                                                 ",SIZE:%.0f",
1222                                                 (double)size);
1223                                         if (!p) {
1224                                                 errno = ENOMEM;
1225                                                 return -1;
1226                                         }
1227                                         n = strlen(p);
1228                                 } else {
1229                                         n = snprintf(buf, bufsize,
1230                                                      ",SIZE:%.0f",
1231                                                      (double)size);
1232                                 }
1233                         } else if (StrCaseCmp(name, "size") == 0) {
1234                                 if (determine_size) {
1235                                         p = talloc_asprintf(
1236                                                 ctx,
1237                                                 "%.0f",
1238                                                 (double)size);
1239                                         if (!p) {
1240                                                 errno = ENOMEM;
1241                                                 return -1;
1242                                         }
1243                                         n = strlen(p);
1244                                 } else {
1245                                         n = snprintf(buf, bufsize,
1246                                                      "%.0f",
1247                                                      (double)size);
1248                                 }
1249                         }
1250
1251                         if (!determine_size && n > bufsize) {
1252                                 errno = ERANGE;
1253                                 return -1;
1254                         }
1255                         buf += n;
1256                         n_used += n;
1257                         bufsize -= n;
1258                         n = 0;
1259                 }
1260
1261                 if (! exclude_dos_create_time &&
1262                     attr_strings.create_time_attr != NULL) {
1263                         if (all || all_dos) {
1264                                 if (determine_size) {
1265                                         p = talloc_asprintf(ctx,
1266                                                             ",%s:%lu",
1267                                                             attr_strings.create_time_attr,
1268                                                             (unsigned long) create_time);
1269                                         if (!p) {
1270                                                 errno = ENOMEM;
1271                                                 return -1;
1272                                         }
1273                                         n = strlen(p);
1274                                 } else {
1275                                         n = snprintf(buf, bufsize,
1276                                                      ",%s:%lu",
1277                                                      attr_strings.create_time_attr,
1278                                                      (unsigned long) create_time);
1279                                 }
1280                         } else if (StrCaseCmp(name, attr_strings.create_time_attr) == 0) {
1281                                 if (determine_size) {
1282                                         p = talloc_asprintf(ctx, "%lu", (unsigned long) create_time);
1283                                         if (!p) {
1284                                                 errno = ENOMEM;
1285                                                 return -1;
1286                                         }
1287                                         n = strlen(p);
1288                                 } else {
1289                                         n = snprintf(buf, bufsize,
1290                                                      "%lu", (unsigned long) create_time);
1291                                 }
1292                         }
1293
1294                         if (!determine_size && n > bufsize) {
1295                                 errno = ERANGE;
1296                                 return -1;
1297                         }
1298                         buf += n;
1299                         n_used += n;
1300                         bufsize -= n;
1301                         n = 0;
1302                 }
1303
1304                 if (! exclude_dos_access_time) {
1305                         if (all || all_dos) {
1306                                 if (determine_size) {
1307                                         p = talloc_asprintf(ctx,
1308                                                             ",%s:%lu",
1309                                                             attr_strings.access_time_attr,
1310                                                             (unsigned long) access_time);
1311                                         if (!p) {
1312                                                 errno = ENOMEM;
1313                                                 return -1;
1314                                         }
1315                                         n = strlen(p);
1316                                 } else {
1317                                         n = snprintf(buf, bufsize,
1318                                                      ",%s:%lu",
1319                                                      attr_strings.access_time_attr,
1320                                                      (unsigned long) access_time);
1321                                 }
1322                         } else if (StrCaseCmp(name, attr_strings.access_time_attr) == 0) {
1323                                 if (determine_size) {
1324                                         p = talloc_asprintf(ctx, "%lu", (unsigned long) access_time);
1325                                         if (!p) {
1326                                                 errno = ENOMEM;
1327                                                 return -1;
1328                                         }
1329                                         n = strlen(p);
1330                                 } else {
1331                                         n = snprintf(buf, bufsize,
1332                                                      "%lu", (unsigned long) access_time);
1333                                 }
1334                         }
1335
1336                         if (!determine_size && n > bufsize) {
1337                                 errno = ERANGE;
1338                                 return -1;
1339                         }
1340                         buf += n;
1341                         n_used += n;
1342                         bufsize -= n;
1343                         n = 0;
1344                 }
1345
1346                 if (! exclude_dos_write_time) {
1347                         if (all || all_dos) {
1348                                 if (determine_size) {
1349                                         p = talloc_asprintf(ctx,
1350                                                             ",%s:%lu",
1351                                                             attr_strings.write_time_attr,
1352                                                             (unsigned long) write_time);
1353                                         if (!p) {
1354                                                 errno = ENOMEM;
1355                                                 return -1;
1356                                         }
1357                                         n = strlen(p);
1358                                 } else {
1359                                         n = snprintf(buf, bufsize,
1360                                                      ",%s:%lu",
1361                                                      attr_strings.write_time_attr,
1362                                                      (unsigned long) write_time);
1363                                 }
1364                         } else if (StrCaseCmp(name, attr_strings.write_time_attr) == 0) {
1365                                 if (determine_size) {
1366                                         p = talloc_asprintf(ctx, "%lu", (unsigned long) write_time);
1367                                         if (!p) {
1368                                                 errno = ENOMEM;
1369                                                 return -1;
1370                                         }
1371                                         n = strlen(p);
1372                                 } else {
1373                                         n = snprintf(buf, bufsize,
1374                                                      "%lu", (unsigned long) write_time);
1375                                 }
1376                         }
1377
1378                         if (!determine_size && n > bufsize) {
1379                                 errno = ERANGE;
1380                                 return -1;
1381                         }
1382                         buf += n;
1383                         n_used += n;
1384                         bufsize -= n;
1385                         n = 0;
1386                 }
1387
1388                 if (! exclude_dos_change_time) {
1389                         if (all || all_dos) {
1390                                 if (determine_size) {
1391                                         p = talloc_asprintf(ctx,
1392                                                             ",%s:%lu",
1393                                                             attr_strings.change_time_attr,
1394                                                             (unsigned long) change_time);
1395                                         if (!p) {
1396                                                 errno = ENOMEM;
1397                                                 return -1;
1398                                         }
1399                                         n = strlen(p);
1400                                 } else {
1401                                         n = snprintf(buf, bufsize,
1402                                                      ",%s:%lu",
1403                                                      attr_strings.change_time_attr,
1404                                                      (unsigned long) change_time);
1405                                 }
1406                         } else if (StrCaseCmp(name, attr_strings.change_time_attr) == 0) {
1407                                 if (determine_size) {
1408                                         p = talloc_asprintf(ctx, "%lu", (unsigned long) change_time);
1409                                         if (!p) {
1410                                                 errno = ENOMEM;
1411                                                 return -1;
1412                                         }
1413                                         n = strlen(p);
1414                                 } else {
1415                                         n = snprintf(buf, bufsize,
1416                                                      "%lu", (unsigned long) change_time);
1417                                 }
1418                         }
1419
1420                         if (!determine_size && n > bufsize) {
1421                                 errno = ERANGE;
1422                                 return -1;
1423                         }
1424                         buf += n;
1425                         n_used += n;
1426                         bufsize -= n;
1427                         n = 0;
1428                 }
1429
1430                 if (! exclude_dos_inode) {
1431                         if (all || all_dos) {
1432                                 if (determine_size) {
1433                                         p = talloc_asprintf(
1434                                                 ctx,
1435                                                 ",INODE:%.0f",
1436                                                 (double)ino);
1437                                         if (!p) {
1438                                                 errno = ENOMEM;
1439                                                 return -1;
1440                                         }
1441                                         n = strlen(p);
1442                                 } else {
1443                                         n = snprintf(buf, bufsize,
1444                                                      ",INODE:%.0f",
1445                                                      (double) ino);
1446                                 }
1447                         } else if (StrCaseCmp(name, "inode") == 0) {
1448                                 if (determine_size) {
1449                                         p = talloc_asprintf(
1450                                                 ctx,
1451                                                 "%.0f",
1452                                                 (double) ino);
1453                                         if (!p) {
1454                                                 errno = ENOMEM;
1455                                                 return -1;
1456                                         }
1457                                         n = strlen(p);
1458                                 } else {
1459                                         n = snprintf(buf, bufsize,
1460                                                      "%.0f",
1461                                                      (double) ino);
1462                                 }
1463                         }
1464
1465                         if (!determine_size && n > bufsize) {
1466                                 errno = ERANGE;
1467                                 return -1;
1468                         }
1469                         buf += n;
1470                         n_used += n;
1471                         bufsize -= n;
1472                         n = 0;
1473                 }
1474
1475                 /* Restore name pointer to its original value */
1476                 name -= 16;
1477         }
1478
1479         if (n_used == 0) {
1480                 errno = ENOATTR;
1481                 return -1;
1482         }
1483
1484         return n_used;
1485 }
1486
1487 /*****************************************************
1488 set the ACLs on a file given an ascii description
1489 *******************************************************/
1490 static int
1491 cacl_set(SMBCCTX *context,
1492         TALLOC_CTX *ctx,
1493         struct cli_state *cli,
1494         struct cli_state *ipc_cli,
1495         struct policy_handle *pol,
1496         const char *filename,
1497         char *the_acl,
1498         int mode,
1499         int flags)
1500 {
1501         uint16_t fnum = (uint16_t)-1;
1502         int err = 0;
1503         SEC_DESC *sd = NULL, *old;
1504         SEC_ACL *dacl = NULL;
1505         DOM_SID *owner_sid = NULL;
1506         DOM_SID *group_sid = NULL;
1507         uint32 i, j;
1508         size_t sd_size;
1509         int ret = 0;
1510         char *p;
1511         bool numeric = True;
1512         char *targetpath = NULL;
1513         struct cli_state *targetcli = NULL;
1514
1515         /* the_acl will be null for REMOVE_ALL operations */
1516         if (the_acl) {
1517                 numeric = ((p = strchr(the_acl, ':')) != NULL &&
1518                            p > the_acl &&
1519                            p[-1] != '+');
1520
1521                 /* if this is to set the entire ACL... */
1522                 if (*the_acl == '*') {
1523                         /* ... then increment past the first colon */
1524                         the_acl = p + 1;
1525                 }
1526
1527                 sd = sec_desc_parse(ctx, ipc_cli, pol, numeric, the_acl);
1528                 if (!sd) {
1529                         errno = EINVAL;
1530                         return -1;
1531                 }
1532         }
1533
1534         /* SMBC_XATTR_MODE_REMOVE_ALL is the only caller
1535            that doesn't deref sd */
1536
1537         if (!sd && (mode != SMBC_XATTR_MODE_REMOVE_ALL)) {
1538                 errno = EINVAL;
1539                 return -1;
1540         }
1541
1542         if (!cli_resolve_path(ctx, "", context->internal->auth_info,
1543                         cli, filename,
1544                         &targetcli, &targetpath)) {
1545                 DEBUG(5,("cacl_set: Could not resolve %s\n", filename));
1546                 errno = ENOENT;
1547                 return -1;
1548         }
1549
1550         /* The desired access below is the only one I could find that works
1551            with NT4, W2KP and Samba */
1552
1553         if (!NT_STATUS_IS_OK(cli_ntcreate(targetcli, targetpath, 0, CREATE_ACCESS_READ, 0,
1554                                 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN, 0x0, 0x0, &fnum))) {
1555                 DEBUG(5, ("cacl_set failed to open %s: %s\n",
1556                           targetpath, cli_errstr(targetcli)));
1557                 errno = 0;
1558                 return -1;
1559         }
1560
1561         old = cli_query_secdesc(targetcli, fnum, ctx);
1562
1563         if (!old) {
1564                 DEBUG(5, ("cacl_set Failed to query old descriptor\n"));
1565                 errno = 0;
1566                 return -1;
1567         }
1568
1569         cli_close(targetcli, fnum);
1570
1571         switch (mode) {
1572         case SMBC_XATTR_MODE_REMOVE_ALL:
1573                 old->dacl->num_aces = 0;
1574                 dacl = old->dacl;
1575                 break;
1576
1577         case SMBC_XATTR_MODE_REMOVE:
1578                 for (i=0;sd->dacl && i<sd->dacl->num_aces;i++) {
1579                         bool found = False;
1580
1581                         for (j=0;old->dacl && j<old->dacl->num_aces;j++) {
1582                                 if (sec_ace_equal(&sd->dacl->aces[i],
1583                                                   &old->dacl->aces[j])) {
1584                                         uint32 k;
1585                                         for (k=j; k<old->dacl->num_aces-1;k++) {
1586                                                 old->dacl->aces[k] =
1587                                                         old->dacl->aces[k+1];
1588                                         }
1589                                         old->dacl->num_aces--;
1590                                         found = True;
1591                                         dacl = old->dacl;
1592                                         break;
1593                                 }
1594                         }
1595
1596                         if (!found) {
1597                                 err = ENOATTR;
1598                                 ret = -1;
1599                                 goto failed;
1600                         }
1601                 }
1602                 break;
1603
1604         case SMBC_XATTR_MODE_ADD:
1605                 for (i=0;sd->dacl && i<sd->dacl->num_aces;i++) {
1606                         bool found = False;
1607
1608                         for (j=0;old->dacl && j<old->dacl->num_aces;j++) {
1609                                 if (sid_equal(&sd->dacl->aces[i].trustee,
1610                                               &old->dacl->aces[j].trustee)) {
1611                                         if (!(flags & SMBC_XATTR_FLAG_CREATE)) {
1612                                                 err = EEXIST;
1613                                                 ret = -1;
1614                                                 goto failed;
1615                                         }
1616                                         old->dacl->aces[j] = sd->dacl->aces[i];
1617                                         ret = -1;
1618                                         found = True;
1619                                 }
1620                         }
1621
1622                         if (!found && (flags & SMBC_XATTR_FLAG_REPLACE)) {
1623                                 err = ENOATTR;
1624                                 ret = -1;
1625                                 goto failed;
1626                         }
1627
1628                         for (i=0;sd->dacl && i<sd->dacl->num_aces;i++) {
1629                                 add_ace(&old->dacl, &sd->dacl->aces[i], ctx);
1630                         }
1631                 }
1632                 dacl = old->dacl;
1633                 break;
1634
1635         case SMBC_XATTR_MODE_SET:
1636                 old = sd;
1637                 owner_sid = old->owner_sid;
1638                 group_sid = old->group_sid;
1639                 dacl = old->dacl;
1640                 break;
1641
1642         case SMBC_XATTR_MODE_CHOWN:
1643                 owner_sid = sd->owner_sid;
1644                 break;
1645
1646         case SMBC_XATTR_MODE_CHGRP:
1647                 group_sid = sd->group_sid;
1648                 break;
1649         }
1650
1651         /* Denied ACE entries must come before allowed ones */
1652         sort_acl(old->dacl);
1653
1654         /* Create new security descriptor and set it */
1655         sd = make_sec_desc(ctx, old->revision, SEC_DESC_SELF_RELATIVE,
1656                            owner_sid, group_sid, NULL, dacl, &sd_size);
1657
1658         if (!NT_STATUS_IS_OK(cli_ntcreate(targetcli, targetpath, 0,
1659                              WRITE_DAC_ACCESS | WRITE_OWNER_ACCESS, 0,
1660                              FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN, 0x0, 0x0, &fnum))) {
1661                 DEBUG(5, ("cacl_set failed to open %s: %s\n",
1662                           targetpath, cli_errstr(targetcli)));
1663                 errno = 0;
1664                 return -1;
1665         }
1666
1667         if (!cli_set_secdesc(targetcli, fnum, sd)) {
1668                 DEBUG(5, ("ERROR: secdesc set failed: %s\n",
1669                         cli_errstr(targetcli)));
1670                 ret = -1;
1671         }
1672
1673         /* Clean up */
1674
1675 failed:
1676         cli_close(targetcli, fnum);
1677
1678         if (err != 0) {
1679                 errno = err;
1680         }
1681
1682         return ret;
1683 }
1684
1685
1686 int
1687 SMBC_setxattr_ctx(SMBCCTX *context,
1688                   const char *fname,
1689                   const char *name,
1690                   const void *value,
1691                   size_t size,
1692                   int flags)
1693 {
1694         int ret;
1695         int ret2;
1696         SMBCSRV *srv = NULL;
1697         SMBCSRV *ipc_srv = NULL;
1698         char *server = NULL;
1699         char *share = NULL;
1700         char *user = NULL;
1701         char *password = NULL;
1702         char *workgroup = NULL;
1703         char *path = NULL;
1704         DOS_ATTR_DESC *dad = NULL;
1705         struct {
1706                 const char * create_time_attr;
1707                 const char * access_time_attr;
1708                 const char * write_time_attr;
1709                 const char * change_time_attr;
1710         } attr_strings;
1711         TALLOC_CTX *frame = talloc_stackframe();
1712
1713         if (!context || !context->internal->initialized) {
1714                 errno = EINVAL;  /* Best I can think of ... */
1715                 TALLOC_FREE(frame);
1716                 return -1;
1717         }
1718
1719         if (!fname) {
1720                 errno = EINVAL;
1721                 TALLOC_FREE(frame);
1722                 return -1;
1723         }
1724
1725         DEBUG(4, ("smbc_setxattr(%s, %s, %.*s)\n",
1726                   fname, name, (int) size, (const char*)value));
1727
1728         if (SMBC_parse_path(frame,
1729                             context,
1730                             fname,
1731                             &workgroup,
1732                             &server,
1733                             &share,
1734                             &path,
1735                             &user,
1736                             &password,
1737                             NULL)) {
1738                 errno = EINVAL;
1739                 TALLOC_FREE(frame);
1740                 return -1;
1741         }
1742
1743         if (!user || user[0] == (char)0) {
1744                 user = talloc_strdup(frame, smbc_getUser(context));
1745                 if (!user) {
1746                         errno = ENOMEM;
1747                         TALLOC_FREE(frame);
1748                         return -1;
1749                 }
1750         }
1751
1752         srv = SMBC_server(frame, context, True,
1753                           server, share, &workgroup, &user, &password);
1754         if (!srv) {
1755                 TALLOC_FREE(frame);
1756                 return -1;  /* errno set by SMBC_server */
1757         }
1758
1759         if (! srv->no_nt_session) {
1760                 ipc_srv = SMBC_attr_server(frame, context, server, share,
1761                                            &workgroup, &user, &password);
1762                 if (! ipc_srv) {
1763                         srv->no_nt_session = True;
1764                 }
1765         } else {
1766                 ipc_srv = NULL;
1767         }
1768
1769         /*
1770          * Are they asking to set the entire set of known attributes?
1771          */
1772         if (StrCaseCmp(name, "system.*") == 0 ||
1773             StrCaseCmp(name, "system.*+") == 0) {
1774                 /* Yup. */
1775                 char *namevalue =
1776                         talloc_asprintf(talloc_tos(), "%s:%s",
1777                                         name+7, (const char *) value);
1778                 if (! namevalue) {
1779                         errno = ENOMEM;
1780                         ret = -1;
1781                         TALLOC_FREE(frame);
1782                         return -1;
1783                 }
1784
1785                 if (ipc_srv) {
1786                         ret = cacl_set(context, talloc_tos(), srv->cli,
1787                                        ipc_srv->cli, &ipc_srv->pol, path,
1788                                        namevalue,
1789                                        (*namevalue == '*'
1790                                         ? SMBC_XATTR_MODE_SET
1791                                         : SMBC_XATTR_MODE_ADD),
1792                                        flags);
1793                 } else {
1794                         ret = 0;
1795                 }
1796
1797                 /* get a DOS Attribute Descriptor with current attributes */
1798                 dad = dos_attr_query(context, talloc_tos(), path, srv);
1799                 if (dad) {
1800                         /* Overwrite old with new, using what was provided */
1801                         dos_attr_parse(context, dad, srv, namevalue);
1802
1803                         /* Set the new DOS attributes */
1804                         if (! SMBC_setatr(context, srv, path,
1805                                           dad->create_time,
1806                                           dad->access_time,
1807                                           dad->write_time,
1808                                           dad->change_time,
1809                                           dad->mode)) {
1810
1811                                 /* cause failure if NT failed too */
1812                                 dad = NULL;
1813                         }
1814                 }
1815
1816                 /* we only fail if both NT and DOS sets failed */
1817                 if (ret < 0 && ! dad) {
1818                         ret = -1; /* in case dad was null */
1819                 }
1820                 else {
1821                         ret = 0;
1822                 }
1823
1824                 TALLOC_FREE(frame);
1825                 return ret;
1826         }
1827
1828         /*
1829          * Are they asking to set an access control element or to set
1830          * the entire access control list?
1831          */
1832         if (StrCaseCmp(name, "system.nt_sec_desc.*") == 0 ||
1833             StrCaseCmp(name, "system.nt_sec_desc.*+") == 0 ||
1834             StrCaseCmp(name, "system.nt_sec_desc.revision") == 0 ||
1835             StrnCaseCmp(name, "system.nt_sec_desc.acl", 22) == 0 ||
1836             StrnCaseCmp(name, "system.nt_sec_desc.acl+", 23) == 0) {
1837
1838                 /* Yup. */
1839                 char *namevalue =
1840                         talloc_asprintf(talloc_tos(), "%s:%s",
1841                                         name+19, (const char *) value);
1842
1843                 if (! ipc_srv) {
1844                         ret = -1; /* errno set by SMBC_server() */
1845                 }
1846                 else if (! namevalue) {
1847                         errno = ENOMEM;
1848                         ret = -1;
1849                 } else {
1850                         ret = cacl_set(context, talloc_tos(), srv->cli,
1851                                        ipc_srv->cli, &ipc_srv->pol, path,
1852                                        namevalue,
1853                                        (*namevalue == '*'
1854                                         ? SMBC_XATTR_MODE_SET
1855                                         : SMBC_XATTR_MODE_ADD),
1856                                        flags);
1857                 }
1858                 TALLOC_FREE(frame);
1859                 return ret;
1860         }
1861
1862         /*
1863          * Are they asking to set the owner?
1864          */
1865         if (StrCaseCmp(name, "system.nt_sec_desc.owner") == 0 ||
1866             StrCaseCmp(name, "system.nt_sec_desc.owner+") == 0) {
1867
1868                 /* Yup. */
1869                 char *namevalue =
1870                         talloc_asprintf(talloc_tos(), "%s:%s",
1871                                         name+19, (const char *) value);
1872
1873                 if (! ipc_srv) {
1874                         ret = -1; /* errno set by SMBC_server() */
1875                 }
1876                 else if (! namevalue) {
1877                         errno = ENOMEM;
1878                         ret = -1;
1879                 } else {
1880                         ret = cacl_set(context, talloc_tos(), srv->cli,
1881                                        ipc_srv->cli, &ipc_srv->pol, path,
1882                                        namevalue, SMBC_XATTR_MODE_CHOWN, 0);
1883                 }
1884                 TALLOC_FREE(frame);
1885                 return ret;
1886         }
1887
1888         /*
1889          * Are they asking to set the group?
1890          */
1891         if (StrCaseCmp(name, "system.nt_sec_desc.group") == 0 ||
1892             StrCaseCmp(name, "system.nt_sec_desc.group+") == 0) {
1893
1894                 /* Yup. */
1895                 char *namevalue =
1896                         talloc_asprintf(talloc_tos(), "%s:%s",
1897                                         name+19, (const char *) value);
1898
1899                 if (! ipc_srv) {
1900                         /* errno set by SMBC_server() */
1901                         ret = -1;
1902                 }
1903                 else if (! namevalue) {
1904                         errno = ENOMEM;
1905                         ret = -1;
1906                 } else {
1907                         ret = cacl_set(context, talloc_tos(), srv->cli,
1908                                        ipc_srv->cli, &ipc_srv->pol, path,
1909                                        namevalue, SMBC_XATTR_MODE_CHGRP, 0);
1910                 }
1911                 TALLOC_FREE(frame);
1912                 return ret;
1913         }
1914
1915         /* Determine whether to use old-style or new-style attribute names */
1916         if (context->internal->full_time_names) {
1917                 /* new-style names */
1918                 attr_strings.create_time_attr = "system.dos_attr.CREATE_TIME";
1919                 attr_strings.access_time_attr = "system.dos_attr.ACCESS_TIME";
1920                 attr_strings.write_time_attr = "system.dos_attr.WRITE_TIME";
1921                 attr_strings.change_time_attr = "system.dos_attr.CHANGE_TIME";
1922         } else {
1923                 /* old-style names */
1924                 attr_strings.create_time_attr = NULL;
1925                 attr_strings.access_time_attr = "system.dos_attr.A_TIME";
1926                 attr_strings.write_time_attr = "system.dos_attr.M_TIME";
1927                 attr_strings.change_time_attr = "system.dos_attr.C_TIME";
1928         }
1929
1930         /*
1931          * Are they asking to set a DOS attribute?
1932          */
1933         if (StrCaseCmp(name, "system.dos_attr.*") == 0 ||
1934             StrCaseCmp(name, "system.dos_attr.mode") == 0 ||
1935             (attr_strings.create_time_attr != NULL &&
1936              StrCaseCmp(name, attr_strings.create_time_attr) == 0) ||
1937             StrCaseCmp(name, attr_strings.access_time_attr) == 0 ||
1938             StrCaseCmp(name, attr_strings.write_time_attr) == 0 ||
1939             StrCaseCmp(name, attr_strings.change_time_attr) == 0) {
1940
1941                 /* get a DOS Attribute Descriptor with current attributes */
1942                 dad = dos_attr_query(context, talloc_tos(), path, srv);
1943                 if (dad) {
1944                         char *namevalue =
1945                                 talloc_asprintf(talloc_tos(), "%s:%s",
1946                                                 name+16, (const char *) value);
1947                         if (! namevalue) {
1948                                 errno = ENOMEM;
1949                                 ret = -1;
1950                         } else {
1951                                 /* Overwrite old with provided new params */
1952                                 dos_attr_parse(context, dad, srv, namevalue);
1953
1954                                 /* Set the new DOS attributes */
1955                                 ret2 = SMBC_setatr(context, srv, path,
1956                                                    dad->create_time,
1957                                                    dad->access_time,
1958                                                    dad->write_time,
1959                                                    dad->change_time,
1960                                                    dad->mode);
1961
1962                                 /* ret2 has True (success) / False (failure) */
1963                                 if (ret2) {
1964                                         ret = 0;
1965                                 } else {
1966                                         ret = -1;
1967                                 }
1968                         }
1969                 } else {
1970                         ret = -1;
1971                 }
1972
1973                 TALLOC_FREE(frame);
1974                 return ret;
1975         }
1976
1977         /* Unsupported attribute name */
1978         errno = EINVAL;
1979         TALLOC_FREE(frame);
1980         return -1;
1981 }
1982
1983 int
1984 SMBC_getxattr_ctx(SMBCCTX *context,
1985                   const char *fname,
1986                   const char *name,
1987                   const void *value,
1988                   size_t size)
1989 {
1990         int ret;
1991         SMBCSRV *srv = NULL;
1992         SMBCSRV *ipc_srv = NULL;
1993         char *server = NULL;
1994         char *share = NULL;
1995         char *user = NULL;
1996         char *password = NULL;
1997         char *workgroup = NULL;
1998         char *path = NULL;
1999         struct {
2000                 const char * create_time_attr;
2001                 const char * access_time_attr;
2002                 const char * write_time_attr;
2003                 const char * change_time_attr;
2004         } attr_strings;
2005         TALLOC_CTX *frame = talloc_stackframe();
2006
2007         if (!context || !context->internal->initialized) {
2008                 errno = EINVAL;  /* Best I can think of ... */
2009                 TALLOC_FREE(frame);
2010                 return -1;
2011         }
2012
2013         if (!fname) {
2014                 errno = EINVAL;
2015                 TALLOC_FREE(frame);
2016                 return -1;
2017         }
2018
2019         DEBUG(4, ("smbc_getxattr(%s, %s)\n", fname, name));
2020
2021         if (SMBC_parse_path(frame,
2022                             context,
2023                             fname,
2024                             &workgroup,
2025                             &server,
2026                             &share,
2027                             &path,
2028                             &user,
2029                             &password,
2030                             NULL)) {
2031                 errno = EINVAL;
2032                 TALLOC_FREE(frame);
2033                 return -1;
2034         }
2035
2036         if (!user || user[0] == (char)0) {
2037                 user = talloc_strdup(frame, smbc_getUser(context));
2038                 if (!user) {
2039                         errno = ENOMEM;
2040                         TALLOC_FREE(frame);
2041                         return -1;
2042                 }
2043         }
2044
2045         srv = SMBC_server(frame, context, True,
2046                           server, share, &workgroup, &user, &password);
2047         if (!srv) {
2048                 TALLOC_FREE(frame);
2049                 return -1;  /* errno set by SMBC_server */
2050         }
2051
2052         if (! srv->no_nt_session) {
2053                 ipc_srv = SMBC_attr_server(frame, context, server, share,
2054                                            &workgroup, &user, &password);
2055                 if (! ipc_srv) {
2056                         srv->no_nt_session = True;
2057                 }
2058         } else {
2059                 ipc_srv = NULL;
2060         }
2061
2062         /* Determine whether to use old-style or new-style attribute names */
2063         if (context->internal->full_time_names) {
2064                 /* new-style names */
2065                 attr_strings.create_time_attr = "system.dos_attr.CREATE_TIME";
2066                 attr_strings.access_time_attr = "system.dos_attr.ACCESS_TIME";
2067                 attr_strings.write_time_attr = "system.dos_attr.WRITE_TIME";
2068                 attr_strings.change_time_attr = "system.dos_attr.CHANGE_TIME";
2069         } else {
2070                 /* old-style names */
2071                 attr_strings.create_time_attr = NULL;
2072                 attr_strings.access_time_attr = "system.dos_attr.A_TIME";
2073                 attr_strings.write_time_attr = "system.dos_attr.M_TIME";
2074                 attr_strings.change_time_attr = "system.dos_attr.C_TIME";
2075         }
2076
2077         /* Are they requesting a supported attribute? */
2078         if (StrCaseCmp(name, "system.*") == 0 ||
2079             StrnCaseCmp(name, "system.*!", 9) == 0 ||
2080             StrCaseCmp(name, "system.*+") == 0 ||
2081             StrnCaseCmp(name, "system.*+!", 10) == 0 ||
2082             StrCaseCmp(name, "system.nt_sec_desc.*") == 0 ||
2083             StrnCaseCmp(name, "system.nt_sec_desc.*!", 21) == 0 ||
2084             StrCaseCmp(name, "system.nt_sec_desc.*+") == 0 ||
2085             StrnCaseCmp(name, "system.nt_sec_desc.*+!", 22) == 0 ||
2086             StrCaseCmp(name, "system.nt_sec_desc.revision") == 0 ||
2087             StrCaseCmp(name, "system.nt_sec_desc.owner") == 0 ||
2088             StrCaseCmp(name, "system.nt_sec_desc.owner+") == 0 ||
2089             StrCaseCmp(name, "system.nt_sec_desc.group") == 0 ||
2090             StrCaseCmp(name, "system.nt_sec_desc.group+") == 0 ||
2091             StrnCaseCmp(name, "system.nt_sec_desc.acl", 22) == 0 ||
2092             StrnCaseCmp(name, "system.nt_sec_desc.acl+", 23) == 0 ||
2093             StrCaseCmp(name, "system.dos_attr.*") == 0 ||
2094             StrnCaseCmp(name, "system.dos_attr.*!", 18) == 0 ||
2095             StrCaseCmp(name, "system.dos_attr.mode") == 0 ||
2096             StrCaseCmp(name, "system.dos_attr.size") == 0 ||
2097             (attr_strings.create_time_attr != NULL &&
2098              StrCaseCmp(name, attr_strings.create_time_attr) == 0) ||
2099             StrCaseCmp(name, attr_strings.access_time_attr) == 0 ||
2100             StrCaseCmp(name, attr_strings.write_time_attr) == 0 ||
2101             StrCaseCmp(name, attr_strings.change_time_attr) == 0 ||
2102             StrCaseCmp(name, "system.dos_attr.inode") == 0) {
2103
2104                 /* Yup. */
2105                 char *filename = (char *) name;
2106                 ret = cacl_get(context, talloc_tos(), srv,
2107                                ipc_srv == NULL ? NULL : ipc_srv->cli,
2108                                &ipc_srv->pol, path,
2109                                filename,
2110                                CONST_DISCARD(char *, value),
2111                                size);
2112                 if (ret < 0 && errno == 0) {
2113                         errno = SMBC_errno(context, srv->cli);
2114                 }
2115                 TALLOC_FREE(frame);
2116                 return ret;
2117         }
2118
2119         /* Unsupported attribute name */
2120         errno = EINVAL;
2121         TALLOC_FREE(frame);
2122         return -1;
2123 }
2124
2125
2126 int
2127 SMBC_removexattr_ctx(SMBCCTX *context,
2128                      const char *fname,
2129                      const char *name)
2130 {
2131         int ret;
2132         SMBCSRV *srv = NULL;
2133         SMBCSRV *ipc_srv = NULL;
2134         char *server = NULL;
2135         char *share = NULL;
2136         char *user = NULL;
2137         char *password = NULL;
2138         char *workgroup = NULL;
2139         char *path = NULL;
2140         TALLOC_CTX *frame = talloc_stackframe();
2141
2142         if (!context || !context->internal->initialized) {
2143                 errno = EINVAL;  /* Best I can think of ... */
2144                 TALLOC_FREE(frame);
2145                 return -1;
2146         }
2147
2148         if (!fname) {
2149                 errno = EINVAL;
2150                 TALLOC_FREE(frame);
2151                 return -1;
2152         }
2153
2154         DEBUG(4, ("smbc_removexattr(%s, %s)\n", fname, name));
2155
2156         if (SMBC_parse_path(frame,
2157                             context,
2158                             fname,
2159                             &workgroup,
2160                             &server,
2161                             &share,
2162                             &path,
2163                             &user,
2164                             &password,
2165                             NULL)) {
2166                 errno = EINVAL;
2167                 TALLOC_FREE(frame);
2168                 return -1;
2169         }
2170
2171         if (!user || user[0] == (char)0) {
2172                 user = talloc_strdup(frame, smbc_getUser(context));
2173                 if (!user) {
2174                         errno = ENOMEM;
2175                         TALLOC_FREE(frame);
2176                         return -1;
2177                 }
2178         }
2179
2180         srv = SMBC_server(frame, context, True,
2181                           server, share, &workgroup, &user, &password);
2182         if (!srv) {
2183                 TALLOC_FREE(frame);
2184                 return -1;  /* errno set by SMBC_server */
2185         }
2186
2187         if (! srv->no_nt_session) {
2188                 ipc_srv = SMBC_attr_server(frame, context, server, share,
2189                                            &workgroup, &user, &password);
2190                 if (! ipc_srv) {
2191                         srv->no_nt_session = True;
2192                 }
2193         } else {
2194                 ipc_srv = NULL;
2195         }
2196
2197         if (! ipc_srv) {
2198                 TALLOC_FREE(frame);
2199                 return -1; /* errno set by SMBC_attr_server */
2200         }
2201
2202         /* Are they asking to set the entire ACL? */
2203         if (StrCaseCmp(name, "system.nt_sec_desc.*") == 0 ||
2204             StrCaseCmp(name, "system.nt_sec_desc.*+") == 0) {
2205
2206                 /* Yup. */
2207                 ret = cacl_set(context, talloc_tos(), srv->cli,
2208                                ipc_srv->cli, &ipc_srv->pol, path,
2209                                NULL, SMBC_XATTR_MODE_REMOVE_ALL, 0);
2210                 TALLOC_FREE(frame);
2211                 return ret;
2212         }
2213
2214         /*
2215          * Are they asking to remove one or more spceific security descriptor
2216          * attributes?
2217          */
2218         if (StrCaseCmp(name, "system.nt_sec_desc.revision") == 0 ||
2219             StrCaseCmp(name, "system.nt_sec_desc.owner") == 0 ||
2220             StrCaseCmp(name, "system.nt_sec_desc.owner+") == 0 ||
2221             StrCaseCmp(name, "system.nt_sec_desc.group") == 0 ||
2222             StrCaseCmp(name, "system.nt_sec_desc.group+") == 0 ||
2223             StrnCaseCmp(name, "system.nt_sec_desc.acl", 22) == 0 ||
2224             StrnCaseCmp(name, "system.nt_sec_desc.acl+", 23) == 0) {
2225
2226                 /* Yup. */
2227                 ret = cacl_set(context, talloc_tos(), srv->cli,
2228                                ipc_srv->cli, &ipc_srv->pol, path,
2229                                CONST_DISCARD(char *, name) + 19,
2230                                SMBC_XATTR_MODE_REMOVE, 0);
2231                 TALLOC_FREE(frame);
2232                 return ret;
2233         }
2234
2235         /* Unsupported attribute name */
2236         errno = EINVAL;
2237         TALLOC_FREE(frame);
2238         return -1;
2239 }
2240
2241 int
2242 SMBC_listxattr_ctx(SMBCCTX *context,
2243                    const char *fname,
2244                    char *list,
2245                    size_t size)
2246 {
2247         /*
2248          * This isn't quite what listxattr() is supposed to do.  This returns
2249          * the complete set of attribute names, always, rather than only those
2250          * attribute names which actually exist for a file.  Hmmm...
2251          */
2252         size_t retsize;
2253         const char supported_old[] =
2254                 "system.*\0"
2255                 "system.*+\0"
2256                 "system.nt_sec_desc.revision\0"
2257                 "system.nt_sec_desc.owner\0"
2258                 "system.nt_sec_desc.owner+\0"
2259                 "system.nt_sec_desc.group\0"
2260                 "system.nt_sec_desc.group+\0"
2261                 "system.nt_sec_desc.acl.*\0"
2262                 "system.nt_sec_desc.acl\0"
2263                 "system.nt_sec_desc.acl+\0"
2264                 "system.nt_sec_desc.*\0"
2265                 "system.nt_sec_desc.*+\0"
2266                 "system.dos_attr.*\0"
2267                 "system.dos_attr.mode\0"
2268                 "system.dos_attr.c_time\0"
2269                 "system.dos_attr.a_time\0"
2270                 "system.dos_attr.m_time\0"
2271                 ;
2272         const char supported_new[] =
2273                 "system.*\0"
2274                 "system.*+\0"
2275                 "system.nt_sec_desc.revision\0"
2276                 "system.nt_sec_desc.owner\0"
2277                 "system.nt_sec_desc.owner+\0"
2278                 "system.nt_sec_desc.group\0"
2279                 "system.nt_sec_desc.group+\0"
2280                 "system.nt_sec_desc.acl.*\0"
2281                 "system.nt_sec_desc.acl\0"
2282                 "system.nt_sec_desc.acl+\0"
2283                 "system.nt_sec_desc.*\0"
2284                 "system.nt_sec_desc.*+\0"
2285                 "system.dos_attr.*\0"
2286                 "system.dos_attr.mode\0"
2287                 "system.dos_attr.create_time\0"
2288                 "system.dos_attr.access_time\0"
2289                 "system.dos_attr.write_time\0"
2290                 "system.dos_attr.change_time\0"
2291                 ;
2292         const char * supported;
2293
2294         if (context->internal->full_time_names) {
2295                 supported = supported_new;
2296                 retsize = sizeof(supported_new);
2297         } else {
2298                 supported = supported_old;
2299                 retsize = sizeof(supported_old);
2300         }
2301
2302         if (size == 0) {
2303                 return retsize;
2304         }
2305
2306         if (retsize > size) {
2307                 errno = ERANGE;
2308                 return -1;
2309         }
2310
2311         /* this can't be strcpy() because there are embedded null characters */
2312         memcpy(list, supported, retsize);
2313         return retsize;
2314 }