projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'devicetree/merge' of git://git.secretlab.ca/git/linux-2.6
[deliverable/linux.git] / fs / cifs / cifsacl.c
1 /*
2 * fs/cifs/cifsacl.c
3 *
4 * Copyright (C) International Business Machines Corp., 2007,2008
5 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
7 * Contains the routines for mapping CIFS/NTFS ACLs
8 *
9 * This library is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU Lesser General Public License as published
11 * by the Free Software Foundation; either version 2.1 of the License, or
12 * (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
17 * the GNU Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public License
20 * along with this library; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23
24 #include <linux/fs.h>
25 #include <linux/slab.h>
26 #include <linux/string.h>
27 #include <linux/keyctl.h>
28 #include <linux/key-type.h>
29 #include <keys/user-type.h>
30 #include "cifspdu.h"
31 #include "cifsglob.h"
32 #include "cifsacl.h"
33 #include "cifsproto.h"
34 #include "cifs_debug.h"
35
36 /* security id for everyone/world system group */
37 static const struct cifs_sid sid_everyone = {
38 1, 1, {0, 0, 0, 0, 0, 1}, {0} };
39 /* security id for Authenticated Users system group */
40 static const struct cifs_sid sid_authusers = {
41 1, 1, {0, 0, 0, 0, 0, 5}, {__constant_cpu_to_le32(11)} };
42 /* group users */
43 static const struct cifs_sid sid_user = {1, 2 , {0, 0, 0, 0, 0, 5}, {} };
44
45 const struct cred *root_cred;
46
47 static void
48 shrink_idmap_tree(struct rb_root *root, int nr_to_scan, int *nr_rem,
49 int *nr_del)
50 {
51 struct rb_node *node;
52 struct rb_node *tmp;
53 struct cifs_sid_id *psidid;
54
55 node = rb_first(root);
56 while (node) {
57 tmp = node;
58 node = rb_next(tmp);
59 psidid = rb_entry(tmp, struct cifs_sid_id, rbnode);
60 if (nr_to_scan == 0 || *nr_del == nr_to_scan)
61 ++(*nr_rem);
62 else {
63 if (time_after(jiffies, psidid->time + SID_MAP_EXPIRE)
64 && psidid->refcount == 0) {
65 rb_erase(tmp, root);
66 ++(*nr_del);
67 } else
68 ++(*nr_rem);
69 }
70 }
71 }
72
73 /*
74 * Run idmap cache shrinker.
75 */
76 static int
77 cifs_idmap_shrinker(struct shrinker *shrink, struct shrink_control *sc)
78 {
79 int nr_to_scan = sc->nr_to_scan;
80 int nr_del = 0;
81 int nr_rem = 0;
82 struct rb_root *root;
83
84 root = &uidtree;
85 spin_lock(&siduidlock);
86 shrink_idmap_tree(root, nr_to_scan, &nr_rem, &nr_del);
87 spin_unlock(&siduidlock);
88
89 root = &gidtree;
90 spin_lock(&sidgidlock);
91 shrink_idmap_tree(root, nr_to_scan, &nr_rem, &nr_del);
92 spin_unlock(&sidgidlock);
93
94 root = &siduidtree;
95 spin_lock(&uidsidlock);
96 shrink_idmap_tree(root, nr_to_scan, &nr_rem, &nr_del);
97 spin_unlock(&uidsidlock);
98
99 root = &sidgidtree;
100 spin_lock(&gidsidlock);
101 shrink_idmap_tree(root, nr_to_scan, &nr_rem, &nr_del);
102 spin_unlock(&gidsidlock);
103
104 return nr_rem;
105 }
106
107 static void
108 sid_rb_insert(struct rb_root *root, unsigned long cid,
109 struct cifs_sid_id **psidid, char *typestr)
110 {
111 char *strptr;
112 struct rb_node *node = root->rb_node;
113 struct rb_node *parent = NULL;
114 struct rb_node **linkto = &(root->rb_node);
115 struct cifs_sid_id *lsidid;
116
117 while (node) {
118 lsidid = rb_entry(node, struct cifs_sid_id, rbnode);
119 parent = node;
120 if (cid > lsidid->id) {
121 linkto = &(node->rb_left);
122 node = node->rb_left;
123 }
124 if (cid < lsidid->id) {
125 linkto = &(node->rb_right);
126 node = node->rb_right;
127 }
128 }
129
130 (*psidid)->id = cid;
131 (*psidid)->time = jiffies - (SID_MAP_RETRY + 1);
132 (*psidid)->refcount = 0;
133
134 sprintf((*psidid)->sidstr, "%s", typestr);
135 strptr = (*psidid)->sidstr + strlen((*psidid)->sidstr);
136 sprintf(strptr, "%ld", cid);
137
138 clear_bit(SID_ID_PENDING, &(*psidid)->state);
139 clear_bit(SID_ID_MAPPED, &(*psidid)->state);
140
141 rb_link_node(&(*psidid)->rbnode, parent, linkto);
142 rb_insert_color(&(*psidid)->rbnode, root);
143 }
144
145 static struct cifs_sid_id *
146 sid_rb_search(struct rb_root *root, unsigned long cid)
147 {
148 struct rb_node *node = root->rb_node;
149 struct cifs_sid_id *lsidid;
150
151 while (node) {
152 lsidid = rb_entry(node, struct cifs_sid_id, rbnode);
153 if (cid > lsidid->id)
154 node = node->rb_left;
155 else if (cid < lsidid->id)
156 node = node->rb_right;
157 else /* node found */
158 return lsidid;
159 }
160
161 return NULL;
162 }
163
164 static struct shrinker cifs_shrinker = {
165 .shrink = cifs_idmap_shrinker,
166 .seeks = DEFAULT_SEEKS,
167 };
168
169 static int
170 cifs_idmap_key_instantiate(struct key *key, const void *data, size_t datalen)
171 {
172 char *payload;
173
174 payload = kmalloc(datalen, GFP_KERNEL);
175 if (!payload)
176 return -ENOMEM;
177
178 memcpy(payload, data, datalen);
179 key->payload.data = payload;
180 key->datalen = datalen;
181 return 0;
182 }
183
184 static inline void
185 cifs_idmap_key_destroy(struct key *key)
186 {
187 kfree(key->payload.data);
188 }
189
190 struct key_type cifs_idmap_key_type = {
191 .name = "cifs.idmap",
192 .instantiate = cifs_idmap_key_instantiate,
193 .destroy = cifs_idmap_key_destroy,
194 .describe = user_describe,
195 .match = user_match,
196 };
197
198 static void
199 sid_to_str(struct cifs_sid *sidptr, char *sidstr)
200 {
201 int i;
202 unsigned long saval;
203 char *strptr;
204
205 strptr = sidstr;
206
207 sprintf(strptr, "%s", "S");
208 strptr = sidstr + strlen(sidstr);
209
210 sprintf(strptr, "-%d", sidptr->revision);
211 strptr = sidstr + strlen(sidstr);
212
213 for (i = 0; i < 6; ++i) {
214 if (sidptr->authority[i]) {
215 sprintf(strptr, "-%d", sidptr->authority[i]);
216 strptr = sidstr + strlen(sidstr);
217 }
218 }
219
220 for (i = 0; i < sidptr->num_subauth; ++i) {
221 saval = le32_to_cpu(sidptr->sub_auth[i]);
222 sprintf(strptr, "-%ld", saval);
223 strptr = sidstr + strlen(sidstr);
224 }
225 }
226
227 static void
228 id_rb_insert(struct rb_root *root, struct cifs_sid *sidptr,
229 struct cifs_sid_id **psidid, char *typestr)
230 {
231 int rc;
232 char *strptr;
233 struct rb_node *node = root->rb_node;
234 struct rb_node *parent = NULL;
235 struct rb_node **linkto = &(root->rb_node);
236 struct cifs_sid_id *lsidid;
237
238 while (node) {
239 lsidid = rb_entry(node, struct cifs_sid_id, rbnode);
240 parent = node;
241 rc = compare_sids(sidptr, &((lsidid)->sid));
242 if (rc > 0) {
243 linkto = &(node->rb_left);
244 node = node->rb_left;
245 } else if (rc < 0) {
246 linkto = &(node->rb_right);
247 node = node->rb_right;
248 }
249 }
250
251 memcpy(&(*psidid)->sid, sidptr, sizeof(struct cifs_sid));
252 (*psidid)->time = jiffies - (SID_MAP_RETRY + 1);
253 (*psidid)->refcount = 0;
254
255 sprintf((*psidid)->sidstr, "%s", typestr);
256 strptr = (*psidid)->sidstr + strlen((*psidid)->sidstr);
257 sid_to_str(&(*psidid)->sid, strptr);
258
259 clear_bit(SID_ID_PENDING, &(*psidid)->state);
260 clear_bit(SID_ID_MAPPED, &(*psidid)->state);
261
262 rb_link_node(&(*psidid)->rbnode, parent, linkto);
263 rb_insert_color(&(*psidid)->rbnode, root);
264 }
265
266 static struct cifs_sid_id *
267 id_rb_search(struct rb_root *root, struct cifs_sid *sidptr)
268 {
269 int rc;
270 struct rb_node *node = root->rb_node;
271 struct cifs_sid_id *lsidid;
272
273 while (node) {
274 lsidid = rb_entry(node, struct cifs_sid_id, rbnode);
275 rc = compare_sids(sidptr, &((lsidid)->sid));
276 if (rc > 0) {
277 node = node->rb_left;
278 } else if (rc < 0) {
279 node = node->rb_right;
280 } else /* node found */
281 return lsidid;
282 }
283
284 return NULL;
285 }
286
287 static int
288 sidid_pending_wait(void *unused)
289 {
290 schedule();
291 return signal_pending(current) ? -ERESTARTSYS : 0;
292 }
293
294 static int
295 id_to_sid(unsigned long cid, uint sidtype, struct cifs_sid *ssid)
296 {
297 int rc = 0;
298 struct key *sidkey;
299 const struct cred *saved_cred;
300 struct cifs_sid *lsid;
301 struct cifs_sid_id *psidid, *npsidid;
302 struct rb_root *cidtree;
303 spinlock_t *cidlock;
304
305 if (sidtype == SIDOWNER) {
306 cidlock = &siduidlock;
307 cidtree = &uidtree;
308 } else if (sidtype == SIDGROUP) {
309 cidlock = &sidgidlock;
310 cidtree = &gidtree;
311 } else
312 return -EINVAL;
313
314 spin_lock(cidlock);
315 psidid = sid_rb_search(cidtree, cid);
316
317 if (!psidid) { /* node does not exist, allocate one & attempt adding */
318 spin_unlock(cidlock);
319 npsidid = kzalloc(sizeof(struct cifs_sid_id), GFP_KERNEL);
320 if (!npsidid)
321 return -ENOMEM;
322
323 npsidid->sidstr = kmalloc(SIDLEN, GFP_KERNEL);
324 if (!npsidid->sidstr) {
325 kfree(npsidid);
326 return -ENOMEM;
327 }
328
329 spin_lock(cidlock);
330 psidid = sid_rb_search(cidtree, cid);
331 if (psidid) { /* node happened to get inserted meanwhile */
332 ++psidid->refcount;
333 spin_unlock(cidlock);
334 kfree(npsidid->sidstr);
335 kfree(npsidid);
336 } else {
337 psidid = npsidid;
338 sid_rb_insert(cidtree, cid, &psidid,
339 sidtype == SIDOWNER ? "oi:" : "gi:");
340 ++psidid->refcount;
341 spin_unlock(cidlock);
342 }
343 } else {
344 ++psidid->refcount;
345 spin_unlock(cidlock);
346 }
347
348 /*
349 * If we are here, it is safe to access psidid and its fields
350 * since a reference was taken earlier while holding the spinlock.
351 * A reference on the node is put without holding the spinlock
352 * and it is OK to do so in this case, shrinker will not erase
353 * this node until all references are put and we do not access
354 * any fields of the node after a reference is put .
355 */
356 if (test_bit(SID_ID_MAPPED, &psidid->state)) {
357 memcpy(ssid, &psidid->sid, sizeof(struct cifs_sid));
358 psidid->time = jiffies; /* update ts for accessing */
359 goto id_sid_out;
360 }
361
362 if (time_after(psidid->time + SID_MAP_RETRY, jiffies)) {
363 rc = -EINVAL;
364 goto id_sid_out;
365 }
366
367 if (!test_and_set_bit(SID_ID_PENDING, &psidid->state)) {
368 saved_cred = override_creds(root_cred);
369 sidkey = request_key(&cifs_idmap_key_type, psidid->sidstr, "");
370 if (IS_ERR(sidkey)) {
371 rc = -EINVAL;
372 cFYI(1, "%s: Can't map and id to a SID", __func__);
373 } else {
374 lsid = (struct cifs_sid *)sidkey->payload.data;
375 memcpy(&psidid->sid, lsid,
376 sidkey->datalen < sizeof(struct cifs_sid) ?
377 sidkey->datalen : sizeof(struct cifs_sid));
378 memcpy(ssid, &psidid->sid,
379 sidkey->datalen < sizeof(struct cifs_sid) ?
380 sidkey->datalen : sizeof(struct cifs_sid));
381 set_bit(SID_ID_MAPPED, &psidid->state);
382 key_put(sidkey);
383 kfree(psidid->sidstr);
384 }
385 psidid->time = jiffies; /* update ts for accessing */
386 revert_creds(saved_cred);
387 clear_bit(SID_ID_PENDING, &psidid->state);
388 wake_up_bit(&psidid->state, SID_ID_PENDING);
389 } else {
390 rc = wait_on_bit(&psidid->state, SID_ID_PENDING,
391 sidid_pending_wait, TASK_INTERRUPTIBLE);
392 if (rc) {
393 cFYI(1, "%s: sidid_pending_wait interrupted %d",
394 __func__, rc);
395 --psidid->refcount;
396 return rc;
397 }
398 if (test_bit(SID_ID_MAPPED, &psidid->state))
399 memcpy(ssid, &psidid->sid, sizeof(struct cifs_sid));
400 else
401 rc = -EINVAL;
402 }
403 id_sid_out:
404 --psidid->refcount;
405 return rc;
406 }
407
408 static int
409 sid_to_id(struct cifs_sb_info *cifs_sb, struct cifs_sid *psid,
410 struct cifs_fattr *fattr, uint sidtype)
411 {
412 int rc;
413 unsigned long cid;
414 struct key *idkey;
415 const struct cred *saved_cred;
416 struct cifs_sid_id *psidid, *npsidid;
417 struct rb_root *cidtree;
418 spinlock_t *cidlock;
419
420 if (sidtype == SIDOWNER) {
421 cid = cifs_sb->mnt_uid; /* default uid, in case upcall fails */
422 cidlock = &siduidlock;
423 cidtree = &uidtree;
424 } else if (sidtype == SIDGROUP) {
425 cid = cifs_sb->mnt_gid; /* default gid, in case upcall fails */
426 cidlock = &sidgidlock;
427 cidtree = &gidtree;
428 } else
429 return -ENOENT;
430
431 spin_lock(cidlock);
432 psidid = id_rb_search(cidtree, psid);
433
434 if (!psidid) { /* node does not exist, allocate one & attempt adding */
435 spin_unlock(cidlock);
436 npsidid = kzalloc(sizeof(struct cifs_sid_id), GFP_KERNEL);
437 if (!npsidid)
438 return -ENOMEM;
439
440 npsidid->sidstr = kmalloc(SIDLEN, GFP_KERNEL);
441 if (!npsidid->sidstr) {
442 kfree(npsidid);
443 return -ENOMEM;
444 }
445
446 spin_lock(cidlock);
447 psidid = id_rb_search(cidtree, psid);
448 if (psidid) { /* node happened to get inserted meanwhile */
449 ++psidid->refcount;
450 spin_unlock(cidlock);
451 kfree(npsidid->sidstr);
452 kfree(npsidid);
453 } else {
454 psidid = npsidid;
455 id_rb_insert(cidtree, psid, &psidid,
456 sidtype == SIDOWNER ? "os:" : "gs:");
457 ++psidid->refcount;
458 spin_unlock(cidlock);
459 }
460 } else {
461 ++psidid->refcount;
462 spin_unlock(cidlock);
463 }
464
465 /*
466 * If we are here, it is safe to access psidid and its fields
467 * since a reference was taken earlier while holding the spinlock.
468 * A reference on the node is put without holding the spinlock
469 * and it is OK to do so in this case, shrinker will not erase
470 * this node until all references are put and we do not access
471 * any fields of the node after a reference is put .
472 */
473 if (test_bit(SID_ID_MAPPED, &psidid->state)) {
474 cid = psidid->id;
475 psidid->time = jiffies; /* update ts for accessing */
476 goto sid_to_id_out;
477 }
478
479 if (time_after(psidid->time + SID_MAP_RETRY, jiffies))
480 goto sid_to_id_out;
481
482 if (!test_and_set_bit(SID_ID_PENDING, &psidid->state)) {
483 saved_cred = override_creds(root_cred);
484 idkey = request_key(&cifs_idmap_key_type, psidid->sidstr, "");
485 if (IS_ERR(idkey))
486 cFYI(1, "%s: Can't map SID to an id", __func__);
487 else {
488 cid = *(unsigned long *)idkey->payload.value;
489 psidid->id = cid;
490 set_bit(SID_ID_MAPPED, &psidid->state);
491 key_put(idkey);
492 kfree(psidid->sidstr);
493 }
494 revert_creds(saved_cred);
495 psidid->time = jiffies; /* update ts for accessing */
496 clear_bit(SID_ID_PENDING, &psidid->state);
497 wake_up_bit(&psidid->state, SID_ID_PENDING);
498 } else {
499 rc = wait_on_bit(&psidid->state, SID_ID_PENDING,
500 sidid_pending_wait, TASK_INTERRUPTIBLE);
501 if (rc) {
502 cFYI(1, "%s: sidid_pending_wait interrupted %d",
503 __func__, rc);
504 --psidid->refcount; /* decremented without spinlock */
505 return rc;
506 }
507 if (test_bit(SID_ID_MAPPED, &psidid->state))
508 cid = psidid->id;
509 }
510
511 sid_to_id_out:
512 --psidid->refcount; /* decremented without spinlock */
513 if (sidtype == SIDOWNER)
514 fattr->cf_uid = cid;
515 else
516 fattr->cf_gid = cid;
517
518 return 0;
519 }
520
521 int
522 init_cifs_idmap(void)
523 {
524 struct cred *cred;
525 struct key *keyring;
526 int ret;
527
528 cFYI(1, "Registering the %s key type\n", cifs_idmap_key_type.name);
529
530 /* create an override credential set with a special thread keyring in
531 * which requests are cached
532 *
533 * this is used to prevent malicious redirections from being installed
534 * with add_key().
535 */
536 cred = prepare_kernel_cred(NULL);
537 if (!cred)
538 return -ENOMEM;
539
540 keyring = key_alloc(&key_type_keyring, ".cifs_idmap", 0, 0, cred,
541 (KEY_POS_ALL & ~KEY_POS_SETATTR) |
542 KEY_USR_VIEW | KEY_USR_READ,
543 KEY_ALLOC_NOT_IN_QUOTA);
544 if (IS_ERR(keyring)) {
545 ret = PTR_ERR(keyring);
546 goto failed_put_cred;
547 }
548
549 ret = key_instantiate_and_link(keyring, NULL, 0, NULL, NULL);
550 if (ret < 0)
551 goto failed_put_key;
552
553 ret = register_key_type(&cifs_idmap_key_type);
554 if (ret < 0)
555 goto failed_put_key;
556
557 /* instruct request_key() to use this special keyring as a cache for
558 * the results it looks up */
559 cred->thread_keyring = keyring;
560 cred->jit_keyring = KEY_REQKEY_DEFL_THREAD_KEYRING;
561 root_cred = cred;
562
563 spin_lock_init(&siduidlock);
564 uidtree = RB_ROOT;
565 spin_lock_init(&sidgidlock);
566 gidtree = RB_ROOT;
567
568 spin_lock_init(&uidsidlock);
569 siduidtree = RB_ROOT;
570 spin_lock_init(&gidsidlock);
571 sidgidtree = RB_ROOT;
572 register_shrinker(&cifs_shrinker);
573
574 cFYI(1, "cifs idmap keyring: %d\n", key_serial(keyring));
575 return 0;
576
577 failed_put_key:
578 key_put(keyring);
579 failed_put_cred:
580 put_cred(cred);
581 return ret;
582 }
583
584 void
585 exit_cifs_idmap(void)
586 {
587 key_revoke(root_cred->thread_keyring);
588 unregister_key_type(&cifs_idmap_key_type);
589 put_cred(root_cred);
590 unregister_shrinker(&cifs_shrinker);
591 cFYI(1, "Unregistered %s key type\n", cifs_idmap_key_type.name);
592 }
593
594 void
595 cifs_destroy_idmaptrees(void)
596 {
597 struct rb_root *root;
598 struct rb_node *node;
599
600 root = &uidtree;
601 spin_lock(&siduidlock);
602 while ((node = rb_first(root)))
603 rb_erase(node, root);
604 spin_unlock(&siduidlock);
605
606 root = &gidtree;
607 spin_lock(&sidgidlock);
608 while ((node = rb_first(root)))
609 rb_erase(node, root);
610 spin_unlock(&sidgidlock);
611
612 root = &siduidtree;
613 spin_lock(&uidsidlock);
614 while ((node = rb_first(root)))
615 rb_erase(node, root);
616 spin_unlock(&uidsidlock);
617
618 root = &sidgidtree;
619 spin_lock(&gidsidlock);
620 while ((node = rb_first(root)))
621 rb_erase(node, root);
622 spin_unlock(&gidsidlock);
623 }
624
625 /* if the two SIDs (roughly equivalent to a UUID for a user or group) are
626 the same returns 1, if they do not match returns 0 */
627 int compare_sids(const struct cifs_sid *ctsid, const struct cifs_sid *cwsid)
628 {
629 int i;
630 int num_subauth, num_sat, num_saw;
631
632 if ((!ctsid) || (!cwsid))
633 return 1;
634
635 /* compare the revision */
636 if (ctsid->revision != cwsid->revision) {
637 if (ctsid->revision > cwsid->revision)
638 return 1;
639 else
640 return -1;
641 }
642
643 /* compare all of the six auth values */
644 for (i = 0; i < 6; ++i) {
645 if (ctsid->authority[i] != cwsid->authority[i]) {
646 if (ctsid->authority[i] > cwsid->authority[i])
647 return 1;
648 else
649 return -1;
650 }
651 }
652
653 /* compare all of the subauth values if any */
654 num_sat = ctsid->num_subauth;
655 num_saw = cwsid->num_subauth;
656 num_subauth = num_sat < num_saw ? num_sat : num_saw;
657 if (num_subauth) {
658 for (i = 0; i < num_subauth; ++i) {
659 if (ctsid->sub_auth[i] != cwsid->sub_auth[i]) {
660 if (le32_to_cpu(ctsid->sub_auth[i]) >
661 le32_to_cpu(cwsid->sub_auth[i]))
662 return 1;
663 else
664 return -1;
665 }
666 }
667 }
668
669 return 0; /* sids compare/match */
670 }
671
672
673 /* copy ntsd, owner sid, and group sid from a security descriptor to another */
674 static void copy_sec_desc(const struct cifs_ntsd *pntsd,
675 struct cifs_ntsd *pnntsd, __u32 sidsoffset)
676 {
677 int i;
678
679 struct cifs_sid *owner_sid_ptr, *group_sid_ptr;
680 struct cifs_sid *nowner_sid_ptr, *ngroup_sid_ptr;
681
682 /* copy security descriptor control portion */
683 pnntsd->revision = pntsd->revision;
684 pnntsd->type = pntsd->type;
685 pnntsd->dacloffset = cpu_to_le32(sizeof(struct cifs_ntsd));
686 pnntsd->sacloffset = 0;
687 pnntsd->osidoffset = cpu_to_le32(sidsoffset);
688 pnntsd->gsidoffset = cpu_to_le32(sidsoffset + sizeof(struct cifs_sid));
689
690 /* copy owner sid */
691 owner_sid_ptr = (struct cifs_sid *)((char *)pntsd +
692 le32_to_cpu(pntsd->osidoffset));
693 nowner_sid_ptr = (struct cifs_sid *)((char *)pnntsd + sidsoffset);
694
695 nowner_sid_ptr->revision = owner_sid_ptr->revision;
696 nowner_sid_ptr->num_subauth = owner_sid_ptr->num_subauth;
697 for (i = 0; i < 6; i++)
698 nowner_sid_ptr->authority[i] = owner_sid_ptr->authority[i];
699 for (i = 0; i < 5; i++)
700 nowner_sid_ptr->sub_auth[i] = owner_sid_ptr->sub_auth[i];
701
702 /* copy group sid */
703 group_sid_ptr = (struct cifs_sid *)((char *)pntsd +
704 le32_to_cpu(pntsd->gsidoffset));
705 ngroup_sid_ptr = (struct cifs_sid *)((char *)pnntsd + sidsoffset +
706 sizeof(struct cifs_sid));
707
708 ngroup_sid_ptr->revision = group_sid_ptr->revision;
709 ngroup_sid_ptr->num_subauth = group_sid_ptr->num_subauth;
710 for (i = 0; i < 6; i++)
711 ngroup_sid_ptr->authority[i] = group_sid_ptr->authority[i];
712 for (i = 0; i < 5; i++)
713 ngroup_sid_ptr->sub_auth[i] = group_sid_ptr->sub_auth[i];
714
715 return;
716 }
717
718
719 /*
720 change posix mode to reflect permissions
721 pmode is the existing mode (we only want to overwrite part of this
722 bits to set can be: S_IRWXU, S_IRWXG or S_IRWXO ie 00700 or 00070 or 00007
723 */
724 static void access_flags_to_mode(__le32 ace_flags, int type, umode_t *pmode,
725 umode_t *pbits_to_set)
726 {
727 __u32 flags = le32_to_cpu(ace_flags);
728 /* the order of ACEs is important. The canonical order is to begin with
729 DENY entries followed by ALLOW, otherwise an allow entry could be
730 encountered first, making the subsequent deny entry like "dead code"
731 which would be superflous since Windows stops when a match is made
732 for the operation you are trying to perform for your user */
733
734 /* For deny ACEs we change the mask so that subsequent allow access
735 control entries do not turn on the bits we are denying */
736 if (type == ACCESS_DENIED) {
737 if (flags & GENERIC_ALL)
738 *pbits_to_set &= ~S_IRWXUGO;
739
740 if ((flags & GENERIC_WRITE) ||
741 ((flags & FILE_WRITE_RIGHTS) == FILE_WRITE_RIGHTS))
742 *pbits_to_set &= ~S_IWUGO;
743 if ((flags & GENERIC_READ) ||
744 ((flags & FILE_READ_RIGHTS) == FILE_READ_RIGHTS))
745 *pbits_to_set &= ~S_IRUGO;
746 if ((flags & GENERIC_EXECUTE) ||
747 ((flags & FILE_EXEC_RIGHTS) == FILE_EXEC_RIGHTS))
748 *pbits_to_set &= ~S_IXUGO;
749 return;
750 } else if (type != ACCESS_ALLOWED) {
751 cERROR(1, "unknown access control type %d", type);
752 return;
753 }
754 /* else ACCESS_ALLOWED type */
755
756 if (flags & GENERIC_ALL) {
757 *pmode |= (S_IRWXUGO & (*pbits_to_set));
758 cFYI(DBG2, "all perms");
759 return;
760 }
761 if ((flags & GENERIC_WRITE) ||
762 ((flags & FILE_WRITE_RIGHTS) == FILE_WRITE_RIGHTS))
763 *pmode |= (S_IWUGO & (*pbits_to_set));
764 if ((flags & GENERIC_READ) ||
765 ((flags & FILE_READ_RIGHTS) == FILE_READ_RIGHTS))
766 *pmode |= (S_IRUGO & (*pbits_to_set));
767 if ((flags & GENERIC_EXECUTE) ||
768 ((flags & FILE_EXEC_RIGHTS) == FILE_EXEC_RIGHTS))
769 *pmode |= (S_IXUGO & (*pbits_to_set));
770
771 cFYI(DBG2, "access flags 0x%x mode now 0x%x", flags, *pmode);
772 return;
773 }
774
775 /*
776 Generate access flags to reflect permissions mode is the existing mode.
777 This function is called for every ACE in the DACL whose SID matches
778 with either owner or group or everyone.
779 */
780
781 static void mode_to_access_flags(umode_t mode, umode_t bits_to_use,
782 __u32 *pace_flags)
783 {
784 /* reset access mask */
785 *pace_flags = 0x0;
786
787 /* bits to use are either S_IRWXU or S_IRWXG or S_IRWXO */
788 mode &= bits_to_use;
789
790 /* check for R/W/X UGO since we do not know whose flags
791 is this but we have cleared all the bits sans RWX for
792 either user or group or other as per bits_to_use */
793 if (mode & S_IRUGO)
794 *pace_flags |= SET_FILE_READ_RIGHTS;
795 if (mode & S_IWUGO)
796 *pace_flags |= SET_FILE_WRITE_RIGHTS;
797 if (mode & S_IXUGO)
798 *pace_flags |= SET_FILE_EXEC_RIGHTS;
799
800 cFYI(DBG2, "mode: 0x%x, access flags now 0x%x", mode, *pace_flags);
801 return;
802 }
803
804 static __u16 fill_ace_for_sid(struct cifs_ace *pntace,
805 const struct cifs_sid *psid, __u64 nmode, umode_t bits)
806 {
807 int i;
808 __u16 size = 0;
809 __u32 access_req = 0;
810
811 pntace->type = ACCESS_ALLOWED;
812 pntace->flags = 0x0;
813 mode_to_access_flags(nmode, bits, &access_req);
814 if (!access_req)
815 access_req = SET_MINIMUM_RIGHTS;
816 pntace->access_req = cpu_to_le32(access_req);
817
818 pntace->sid.revision = psid->revision;
819 pntace->sid.num_subauth = psid->num_subauth;
820 for (i = 0; i < 6; i++)
821 pntace->sid.authority[i] = psid->authority[i];
822 for (i = 0; i < psid->num_subauth; i++)
823 pntace->sid.sub_auth[i] = psid->sub_auth[i];
824
825 size = 1 + 1 + 2 + 4 + 1 + 1 + 6 + (psid->num_subauth * 4);
826 pntace->size = cpu_to_le16(size);
827
828 return size;
829 }
830
831
832 #ifdef CONFIG_CIFS_DEBUG2
833 static void dump_ace(struct cifs_ace *pace, char *end_of_acl)
834 {
835 int num_subauth;
836
837 /* validate that we do not go past end of acl */
838
839 if (le16_to_cpu(pace->size) < 16) {
840 cERROR(1, "ACE too small %d", le16_to_cpu(pace->size));
841 return;
842 }
843
844 if (end_of_acl < (char *)pace + le16_to_cpu(pace->size)) {
845 cERROR(1, "ACL too small to parse ACE");
846 return;
847 }
848
849 num_subauth = pace->sid.num_subauth;
850 if (num_subauth) {
851 int i;
852 cFYI(1, "ACE revision %d num_auth %d type %d flags %d size %d",
853 pace->sid.revision, pace->sid.num_subauth, pace->type,
854 pace->flags, le16_to_cpu(pace->size));
855 for (i = 0; i < num_subauth; ++i) {
856 cFYI(1, "ACE sub_auth[%d]: 0x%x", i,
857 le32_to_cpu(pace->sid.sub_auth[i]));
858 }
859
860 /* BB add length check to make sure that we do not have huge
861 num auths and therefore go off the end */
862 }
863
864 return;
865 }
866 #endif
867
868
869 static void parse_dacl(struct cifs_acl *pdacl, char *end_of_acl,
870 struct cifs_sid *pownersid, struct cifs_sid *pgrpsid,
871 struct cifs_fattr *fattr)
872 {
873 int i;
874 int num_aces = 0;
875 int acl_size;
876 char *acl_base;
877 struct cifs_ace **ppace;
878
879 /* BB need to add parm so we can store the SID BB */
880
881 if (!pdacl) {
882 /* no DACL in the security descriptor, set
883 all the permissions for user/group/other */
884 fattr->cf_mode |= S_IRWXUGO;
885 return;
886 }
887
888 /* validate that we do not go past end of acl */
889 if (end_of_acl < (char *)pdacl + le16_to_cpu(pdacl->size)) {
890 cERROR(1, "ACL too small to parse DACL");
891 return;
892 }
893
894 cFYI(DBG2, "DACL revision %d size %d num aces %d",
895 le16_to_cpu(pdacl->revision), le16_to_cpu(pdacl->size),
896 le32_to_cpu(pdacl->num_aces));
897
898 /* reset rwx permissions for user/group/other.
899 Also, if num_aces is 0 i.e. DACL has no ACEs,
900 user/group/other have no permissions */
901 fattr->cf_mode &= ~(S_IRWXUGO);
902
903 acl_base = (char *)pdacl;
904 acl_size = sizeof(struct cifs_acl);
905
906 num_aces = le32_to_cpu(pdacl->num_aces);
907 if (num_aces > 0) {
908 umode_t user_mask = S_IRWXU;
909 umode_t group_mask = S_IRWXG;
910 umode_t other_mask = S_IRWXU | S_IRWXG | S_IRWXO;
911
912 ppace = kmalloc(num_aces * sizeof(struct cifs_ace *),
913 GFP_KERNEL);
914 if (!ppace) {
915 cERROR(1, "DACL memory allocation error");
916 return;
917 }
918
919 for (i = 0; i < num_aces; ++i) {
920 ppace[i] = (struct cifs_ace *) (acl_base + acl_size);
921 #ifdef CONFIG_CIFS_DEBUG2
922 dump_ace(ppace[i], end_of_acl);
923 #endif
924 if (compare_sids(&(ppace[i]->sid), pownersid) == 0)
925 access_flags_to_mode(ppace[i]->access_req,
926 ppace[i]->type,
927 &fattr->cf_mode,
928 &user_mask);
929 if (compare_sids(&(ppace[i]->sid), pgrpsid) == 0)
930 access_flags_to_mode(ppace[i]->access_req,
931 ppace[i]->type,
932 &fattr->cf_mode,
933 &group_mask);
934 if (compare_sids(&(ppace[i]->sid), &sid_everyone) == 0)
935 access_flags_to_mode(ppace[i]->access_req,
936 ppace[i]->type,
937 &fattr->cf_mode,
938 &other_mask);
939 if (compare_sids(&(ppace[i]->sid), &sid_authusers) == 0)
940 access_flags_to_mode(ppace[i]->access_req,
941 ppace[i]->type,
942 &fattr->cf_mode,
943 &other_mask);
944
945
946 /* memcpy((void *)(&(cifscred->aces[i])),
947 (void *)ppace[i],
948 sizeof(struct cifs_ace)); */
949
950 acl_base = (char *)ppace[i];
951 acl_size = le16_to_cpu(ppace[i]->size);
952 }
953
954 kfree(ppace);
955 }
956
957 return;
958 }
959
960
961 static int set_chmod_dacl(struct cifs_acl *pndacl, struct cifs_sid *pownersid,
962 struct cifs_sid *pgrpsid, __u64 nmode)
963 {
964 u16 size = 0;
965 struct cifs_acl *pnndacl;
966
967 pnndacl = (struct cifs_acl *)((char *)pndacl + sizeof(struct cifs_acl));
968
969 size += fill_ace_for_sid((struct cifs_ace *) ((char *)pnndacl + size),
970 pownersid, nmode, S_IRWXU);
971 size += fill_ace_for_sid((struct cifs_ace *)((char *)pnndacl + size),
972 pgrpsid, nmode, S_IRWXG);
973 size += fill_ace_for_sid((struct cifs_ace *)((char *)pnndacl + size),
974 &sid_everyone, nmode, S_IRWXO);
975
976 pndacl->size = cpu_to_le16(size + sizeof(struct cifs_acl));
977 pndacl->num_aces = cpu_to_le32(3);
978
979 return 0;
980 }
981
982
983 static int parse_sid(struct cifs_sid *psid, char *end_of_acl)
984 {
985 /* BB need to add parm so we can store the SID BB */
986
987 /* validate that we do not go past end of ACL - sid must be at least 8
988 bytes long (assuming no sub-auths - e.g. the null SID */
989 if (end_of_acl < (char *)psid + 8) {
990 cERROR(1, "ACL too small to parse SID %p", psid);
991 return -EINVAL;
992 }
993
994 if (psid->num_subauth) {
995 #ifdef CONFIG_CIFS_DEBUG2
996 int i;
997 cFYI(1, "SID revision %d num_auth %d",
998 psid->revision, psid->num_subauth);
999
1000 for (i = 0; i < psid->num_subauth; i++) {
1001 cFYI(1, "SID sub_auth[%d]: 0x%x ", i,
1002 le32_to_cpu(psid->sub_auth[i]));
1003 }
1004
1005 /* BB add length check to make sure that we do not have huge
1006 num auths and therefore go off the end */
1007 cFYI(1, "RID 0x%x",
1008 le32_to_cpu(psid->sub_auth[psid->num_subauth-1]));
1009 #endif
1010 }
1011
1012 return 0;
1013 }
1014
1015
1016 /* Convert CIFS ACL to POSIX form */
1017 static int parse_sec_desc(struct cifs_sb_info *cifs_sb,
1018 struct cifs_ntsd *pntsd, int acl_len, struct cifs_fattr *fattr)
1019 {
1020 int rc = 0;
1021 struct cifs_sid *owner_sid_ptr, *group_sid_ptr;
1022 struct cifs_acl *dacl_ptr; /* no need for SACL ptr */
1023 char *end_of_acl = ((char *)pntsd) + acl_len;
1024 __u32 dacloffset;
1025
1026 if (pntsd == NULL)
1027 return -EIO;
1028
1029 owner_sid_ptr = (struct cifs_sid *)((char *)pntsd +
1030 le32_to_cpu(pntsd->osidoffset));
1031 group_sid_ptr = (struct cifs_sid *)((char *)pntsd +
1032 le32_to_cpu(pntsd->gsidoffset));
1033 dacloffset = le32_to_cpu(pntsd->dacloffset);
1034 dacl_ptr = (struct cifs_acl *)((char *)pntsd + dacloffset);
1035 cFYI(DBG2, "revision %d type 0x%x ooffset 0x%x goffset 0x%x "
1036 "sacloffset 0x%x dacloffset 0x%x",
1037 pntsd->revision, pntsd->type, le32_to_cpu(pntsd->osidoffset),
1038 le32_to_cpu(pntsd->gsidoffset),
1039 le32_to_cpu(pntsd->sacloffset), dacloffset);
1040 /* cifs_dump_mem("owner_sid: ", owner_sid_ptr, 64); */
1041 rc = parse_sid(owner_sid_ptr, end_of_acl);
1042 if (rc) {
1043 cFYI(1, "%s: Error %d parsing Owner SID", __func__, rc);
1044 return rc;
1045 }
1046 rc = sid_to_id(cifs_sb, owner_sid_ptr, fattr, SIDOWNER);
1047 if (rc) {
1048 cFYI(1, "%s: Error %d mapping Owner SID to uid", __func__, rc);
1049 return rc;
1050 }
1051
1052 rc = parse_sid(group_sid_ptr, end_of_acl);
1053 if (rc) {
1054 cFYI(1, "%s: Error %d mapping Owner SID to gid", __func__, rc);
1055 return rc;
1056 }
1057 rc = sid_to_id(cifs_sb, group_sid_ptr, fattr, SIDGROUP);
1058 if (rc) {
1059 cFYI(1, "%s: Error %d mapping Group SID to gid", __func__, rc);
1060 return rc;
1061 }
1062
1063 if (dacloffset)
1064 parse_dacl(dacl_ptr, end_of_acl, owner_sid_ptr,
1065 group_sid_ptr, fattr);
1066 else
1067 cFYI(1, "no ACL"); /* BB grant all or default perms? */
1068
1069 return rc;
1070 }
1071
1072 /* Convert permission bits from mode to equivalent CIFS ACL */
1073 static int build_sec_desc(struct cifs_ntsd *pntsd, struct cifs_ntsd *pnntsd,
1074 __u32 secdesclen, __u64 nmode, uid_t uid, gid_t gid, int *aclflag)
1075 {
1076 int rc = 0;
1077 __u32 dacloffset;
1078 __u32 ndacloffset;
1079 __u32 sidsoffset;
1080 struct cifs_sid *owner_sid_ptr, *group_sid_ptr;
1081 struct cifs_sid *nowner_sid_ptr, *ngroup_sid_ptr;
1082 struct cifs_acl *dacl_ptr = NULL; /* no need for SACL ptr */
1083 struct cifs_acl *ndacl_ptr = NULL; /* no need for SACL ptr */
1084
1085 if (nmode != NO_CHANGE_64) { /* chmod */
1086 owner_sid_ptr = (struct cifs_sid *)((char *)pntsd +
1087 le32_to_cpu(pntsd->osidoffset));
1088 group_sid_ptr = (struct cifs_sid *)((char *)pntsd +
1089 le32_to_cpu(pntsd->gsidoffset));
1090 dacloffset = le32_to_cpu(pntsd->dacloffset);
1091 dacl_ptr = (struct cifs_acl *)((char *)pntsd + dacloffset);
1092 ndacloffset = sizeof(struct cifs_ntsd);
1093 ndacl_ptr = (struct cifs_acl *)((char *)pnntsd + ndacloffset);
1094 ndacl_ptr->revision = dacl_ptr->revision;
1095 ndacl_ptr->size = 0;
1096 ndacl_ptr->num_aces = 0;
1097
1098 rc = set_chmod_dacl(ndacl_ptr, owner_sid_ptr, group_sid_ptr,
1099 nmode);
1100 sidsoffset = ndacloffset + le16_to_cpu(ndacl_ptr->size);
1101 /* copy sec desc control portion & owner and group sids */
1102 copy_sec_desc(pntsd, pnntsd, sidsoffset);
1103 *aclflag = CIFS_ACL_DACL;
1104 } else {
1105 memcpy(pnntsd, pntsd, secdesclen);
1106 if (uid != NO_CHANGE_32) { /* chown */
1107 owner_sid_ptr = (struct cifs_sid *)((char *)pnntsd +
1108 le32_to_cpu(pnntsd->osidoffset));
1109 nowner_sid_ptr = kmalloc(sizeof(struct cifs_sid),
1110 GFP_KERNEL);
1111 if (!nowner_sid_ptr)
1112 return -ENOMEM;
1113 rc = id_to_sid(uid, SIDOWNER, nowner_sid_ptr);
1114 if (rc) {
1115 cFYI(1, "%s: Mapping error %d for owner id %d",
1116 __func__, rc, uid);
1117 kfree(nowner_sid_ptr);
1118 return rc;
1119 }
1120 memcpy(owner_sid_ptr, nowner_sid_ptr,
1121 sizeof(struct cifs_sid));
1122 kfree(nowner_sid_ptr);
1123 *aclflag = CIFS_ACL_OWNER;
1124 }
1125 if (gid != NO_CHANGE_32) { /* chgrp */
1126 group_sid_ptr = (struct cifs_sid *)((char *)pnntsd +
1127 le32_to_cpu(pnntsd->gsidoffset));
1128 ngroup_sid_ptr = kmalloc(sizeof(struct cifs_sid),
1129 GFP_KERNEL);
1130 if (!ngroup_sid_ptr)
1131 return -ENOMEM;
1132 rc = id_to_sid(gid, SIDGROUP, ngroup_sid_ptr);
1133 if (rc) {
1134 cFYI(1, "%s: Mapping error %d for group id %d",
1135 __func__, rc, gid);
1136 kfree(ngroup_sid_ptr);
1137 return rc;
1138 }
1139 memcpy(group_sid_ptr, ngroup_sid_ptr,
1140 sizeof(struct cifs_sid));
1141 kfree(ngroup_sid_ptr);
1142 *aclflag = CIFS_ACL_GROUP;
1143 }
1144 }
1145
1146 return rc;
1147 }
1148
1149 static struct cifs_ntsd *get_cifs_acl_by_fid(struct cifs_sb_info *cifs_sb,
1150 __u16 fid, u32 *pacllen)
1151 {
1152 struct cifs_ntsd *pntsd = NULL;
1153 int xid, rc;
1154 struct tcon_link *tlink = cifs_sb_tlink(cifs_sb);
1155
1156 if (IS_ERR(tlink))
1157 return ERR_CAST(tlink);
1158
1159 xid = GetXid();
1160 rc = CIFSSMBGetCIFSACL(xid, tlink_tcon(tlink), fid, &pntsd, pacllen);
1161 FreeXid(xid);
1162
1163 cifs_put_tlink(tlink);
1164
1165 cFYI(1, "%s: rc = %d ACL len %d", __func__, rc, *pacllen);
1166 if (rc)
1167 return ERR_PTR(rc);
1168 return pntsd;
1169 }
1170
1171 static struct cifs_ntsd *get_cifs_acl_by_path(struct cifs_sb_info *cifs_sb,
1172 const char *path, u32 *pacllen)
1173 {
1174 struct cifs_ntsd *pntsd = NULL;
1175 int oplock = 0;
1176 int xid, rc, create_options = 0;
1177 __u16 fid;
1178 struct cifs_tcon *tcon;
1179 struct tcon_link *tlink = cifs_sb_tlink(cifs_sb);
1180
1181 if (IS_ERR(tlink))
1182 return ERR_CAST(tlink);
1183
1184 tcon = tlink_tcon(tlink);
1185 xid = GetXid();
1186
1187 if (backup_cred(cifs_sb))
1188 create_options |= CREATE_OPEN_BACKUP_INTENT;
1189
1190 rc = CIFSSMBOpen(xid, tcon, path, FILE_OPEN, READ_CONTROL,
1191 create_options, &fid, &oplock, NULL, cifs_sb->local_nls,
1192 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1193 if (!rc) {
1194 rc = CIFSSMBGetCIFSACL(xid, tcon, fid, &pntsd, pacllen);
1195 CIFSSMBClose(xid, tcon, fid);
1196 }
1197
1198 cifs_put_tlink(tlink);
1199 FreeXid(xid);
1200
1201 cFYI(1, "%s: rc = %d ACL len %d", __func__, rc, *pacllen);
1202 if (rc)
1203 return ERR_PTR(rc);
1204 return pntsd;
1205 }
1206
1207 /* Retrieve an ACL from the server */
1208 struct cifs_ntsd *get_cifs_acl(struct cifs_sb_info *cifs_sb,
1209 struct inode *inode, const char *path,
1210 u32 *pacllen)
1211 {
1212 struct cifs_ntsd *pntsd = NULL;
1213 struct cifsFileInfo *open_file = NULL;
1214
1215 if (inode)
1216 open_file = find_readable_file(CIFS_I(inode), true);
1217 if (!open_file)
1218 return get_cifs_acl_by_path(cifs_sb, path, pacllen);
1219
1220 pntsd = get_cifs_acl_by_fid(cifs_sb, open_file->netfid, pacllen);
1221 cifsFileInfo_put(open_file);
1222 return pntsd;
1223 }
1224
1225 /* Set an ACL on the server */
1226 int set_cifs_acl(struct cifs_ntsd *pnntsd, __u32 acllen,
1227 struct inode *inode, const char *path, int aclflag)
1228 {
1229 int oplock = 0;
1230 int xid, rc, access_flags, create_options = 0;
1231 __u16 fid;
1232 struct cifs_tcon *tcon;
1233 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1234 struct tcon_link *tlink = cifs_sb_tlink(cifs_sb);
1235
1236 if (IS_ERR(tlink))
1237 return PTR_ERR(tlink);
1238
1239 tcon = tlink_tcon(tlink);
1240 xid = GetXid();
1241
1242 if (backup_cred(cifs_sb))
1243 create_options |= CREATE_OPEN_BACKUP_INTENT;
1244
1245 if (aclflag == CIFS_ACL_OWNER || aclflag == CIFS_ACL_GROUP)
1246 access_flags = WRITE_OWNER;
1247 else
1248 access_flags = WRITE_DAC;
1249
1250 rc = CIFSSMBOpen(xid, tcon, path, FILE_OPEN, access_flags,
1251 create_options, &fid, &oplock, NULL, cifs_sb->local_nls,
1252 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1253 if (rc) {
1254 cERROR(1, "Unable to open file to set ACL");
1255 goto out;
1256 }
1257
1258 rc = CIFSSMBSetCIFSACL(xid, tcon, fid, pnntsd, acllen, aclflag);
1259 cFYI(DBG2, "SetCIFSACL rc = %d", rc);
1260
1261 CIFSSMBClose(xid, tcon, fid);
1262 out:
1263 FreeXid(xid);
1264 cifs_put_tlink(tlink);
1265 return rc;
1266 }
1267
1268 /* Translate the CIFS ACL (simlar to NTFS ACL) for a file into mode bits */
1269 int
1270 cifs_acl_to_fattr(struct cifs_sb_info *cifs_sb, struct cifs_fattr *fattr,
1271 struct inode *inode, const char *path, const __u16 *pfid)
1272 {
1273 struct cifs_ntsd *pntsd = NULL;
1274 u32 acllen = 0;
1275 int rc = 0;
1276
1277 cFYI(DBG2, "converting ACL to mode for %s", path);
1278
1279 if (pfid)
1280 pntsd = get_cifs_acl_by_fid(cifs_sb, *pfid, &acllen);
1281 else
1282 pntsd = get_cifs_acl(cifs_sb, inode, path, &acllen);
1283
1284 /* if we can retrieve the ACL, now parse Access Control Entries, ACEs */
1285 if (IS_ERR(pntsd)) {
1286 rc = PTR_ERR(pntsd);
1287 cERROR(1, "%s: error %d getting sec desc", __func__, rc);
1288 } else {
1289 rc = parse_sec_desc(cifs_sb, pntsd, acllen, fattr);
1290 kfree(pntsd);
1291 if (rc)
1292 cERROR(1, "parse sec desc failed rc = %d", rc);
1293 }
1294
1295 return rc;
1296 }
1297
1298 /* Convert mode bits to an ACL so we can update the ACL on the server */
1299 int
1300 id_mode_to_cifs_acl(struct inode *inode, const char *path, __u64 nmode,
1301 uid_t uid, gid_t gid)
1302 {
1303 int rc = 0;
1304 int aclflag = CIFS_ACL_DACL; /* default flag to set */
1305 __u32 secdesclen = 0;
1306 struct cifs_ntsd *pntsd = NULL; /* acl obtained from server */
1307 struct cifs_ntsd *pnntsd = NULL; /* modified acl to be sent to server */
1308
1309 cFYI(DBG2, "set ACL from mode for %s", path);
1310
1311 /* Get the security descriptor */
1312 pntsd = get_cifs_acl(CIFS_SB(inode->i_sb), inode, path, &secdesclen);
1313
1314 /* Add three ACEs for owner, group, everyone getting rid of
1315 other ACEs as chmod disables ACEs and set the security descriptor */
1316
1317 if (IS_ERR(pntsd)) {
1318 rc = PTR_ERR(pntsd);
1319 cERROR(1, "%s: error %d getting sec desc", __func__, rc);
1320 } else {
1321 /* allocate memory for the smb header,
1322 set security descriptor request security descriptor
1323 parameters, and secuirty descriptor itself */
1324
1325 secdesclen = secdesclen < DEFSECDESCLEN ?
1326 DEFSECDESCLEN : secdesclen;
1327 pnntsd = kmalloc(secdesclen, GFP_KERNEL);
1328 if (!pnntsd) {
1329 cERROR(1, "Unable to allocate security descriptor");
1330 kfree(pntsd);
1331 return -ENOMEM;
1332 }
1333
1334 rc = build_sec_desc(pntsd, pnntsd, secdesclen, nmode, uid, gid,
1335 &aclflag);
1336
1337 cFYI(DBG2, "build_sec_desc rc: %d", rc);
1338
1339 if (!rc) {
1340 /* Set the security descriptor */
1341 rc = set_cifs_acl(pnntsd, secdesclen, inode,
1342 path, aclflag);
1343 cFYI(DBG2, "set_cifs_acl rc: %d", rc);
1344 }
1345
1346 kfree(pnntsd);
1347 kfree(pntsd);
1348 }
1349
1350 return rc;
1351 }
Linux kernel - Deliverables
This page took 0.060816 seconds and 5 git commands to generate.