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