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