[CIFS] Allow setting mode via cifs acl
[linux-2.6.git] / fs / cifs / cifsacl.c
1 /*
2  *   fs/cifs/cifsacl.c
3  *
4  *   Copyright (C) International Business Machines  Corp., 2007
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 "cifspdu.h"
26 #include "cifsglob.h"
27 #include "cifsacl.h"
28 #include "cifsproto.h"
29 #include "cifs_debug.h"
30
31
32 #ifdef CONFIG_CIFS_EXPERIMENTAL
33
34 static struct cifs_wksid wksidarr[NUM_WK_SIDS] = {
35         {{1, 0, {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0} }, "null user"},
36         {{1, 1, {0, 0, 0, 0, 0, 1}, {0, 0, 0, 0, 0} }, "nobody"},
37         {{1, 1, {0, 0, 0, 0, 0, 5}, {cpu_to_le32(11), 0, 0, 0, 0} }, "net-users"},
38         {{1, 1, {0, 0, 0, 0, 0, 5}, {cpu_to_le32(18), 0, 0, 0, 0} }, "sys"},
39         {{1, 2, {0, 0, 0, 0, 0, 5}, {cpu_to_le32(32), cpu_to_le32(544), 0, 0, 0} }, "root"},
40         {{1, 2, {0, 0, 0, 0, 0, 5}, {cpu_to_le32(32), cpu_to_le32(545), 0, 0, 0} }, "users"},
41         {{1, 2, {0, 0, 0, 0, 0, 5}, {cpu_to_le32(32), cpu_to_le32(546), 0, 0, 0} }, "guest"} }
42 ;
43
44
45 /* security id for everyone */
46 static const struct cifs_sid sid_everyone = {
47         1, 1, {0, 0, 0, 0, 0, 1}, {0} };
48 /* group users */
49 static const struct cifs_sid sid_user =
50                 {1, 2 , {0, 0, 0, 0, 0, 5}, {} };
51
52
53 int match_sid(struct cifs_sid *ctsid)
54 {
55         int i, j;
56         int num_subauth, num_sat, num_saw;
57         struct cifs_sid *cwsid;
58
59         if (!ctsid)
60                 return (-1);
61
62         for (i = 0; i < NUM_WK_SIDS; ++i) {
63                 cwsid = &(wksidarr[i].cifssid);
64
65                 /* compare the revision */
66                 if (ctsid->revision != cwsid->revision)
67                         continue;
68
69                 /* compare all of the six auth values */
70                 for (j = 0; j < 6; ++j) {
71                         if (ctsid->authority[j] != cwsid->authority[j])
72                                 break;
73                 }
74                 if (j < 6)
75                         continue; /* all of the auth values did not match */
76
77                 /* compare all of the subauth values if any */
78                 num_sat = ctsid->num_subauth;
79                 num_saw = cwsid->num_subauth;
80                 num_subauth = num_sat < num_saw ? num_sat : num_saw;
81                 if (num_subauth) {
82                         for (j = 0; j < num_subauth; ++j) {
83                                 if (ctsid->sub_auth[j] != cwsid->sub_auth[j])
84                                         break;
85                         }
86                         if (j < num_subauth)
87                                 continue; /* all sub_auth values do not match */
88                 }
89
90                 cFYI(1, ("matching sid: %s\n", wksidarr[i].sidname));
91                 return (0); /* sids compare/match */
92         }
93
94         cFYI(1, ("No matching sid"));
95         return (-1);
96 }
97
98 /* if the two SIDs (roughly equivalent to a UUID for a user or group) are
99    the same returns 1, if they do not match returns 0 */
100 int compare_sids(const struct cifs_sid *ctsid, const struct cifs_sid *cwsid)
101 {
102         int i;
103         int num_subauth, num_sat, num_saw;
104
105         if ((!ctsid) || (!cwsid))
106                 return (0);
107
108         /* compare the revision */
109         if (ctsid->revision != cwsid->revision)
110                 return (0);
111
112         /* compare all of the six auth values */
113         for (i = 0; i < 6; ++i) {
114                 if (ctsid->authority[i] != cwsid->authority[i])
115                         return (0);
116         }
117
118         /* compare all of the subauth values if any */
119         num_sat = ctsid->num_subauth;
120         num_saw = cwsid->num_subauth;
121         num_subauth = num_sat < num_saw ? num_sat : num_saw;
122         if (num_subauth) {
123                 for (i = 0; i < num_subauth; ++i) {
124                         if (ctsid->sub_auth[i] != cwsid->sub_auth[i])
125                                 return (0);
126                 }
127         }
128
129         return (1); /* sids compare/match */
130 }
131
132
133 /* copy ntsd, owner sid, and group sid from a security descriptor to another */
134 static void copy_sec_desc(const struct cifs_ntsd *pntsd,
135                                 struct cifs_ntsd *pnntsd, __u32 sidsoffset)
136 {
137         int i;
138
139         struct cifs_sid *owner_sid_ptr, *group_sid_ptr;
140         struct cifs_sid *nowner_sid_ptr, *ngroup_sid_ptr;
141
142         /* copy security descriptor control portion */
143         pnntsd->revision = pntsd->revision;
144         pnntsd->type = pntsd->type;
145         pnntsd->dacloffset = cpu_to_le32(sizeof(struct cifs_ntsd));
146         pnntsd->sacloffset = 0;
147         pnntsd->osidoffset = cpu_to_le32(sidsoffset);
148         pnntsd->gsidoffset = cpu_to_le32(sidsoffset + sizeof(struct cifs_sid));
149
150         /* copy owner sid */
151         owner_sid_ptr = (struct cifs_sid *)((char *)pntsd +
152                                 le32_to_cpu(pntsd->osidoffset));
153         nowner_sid_ptr = (struct cifs_sid *)((char *)pnntsd + sidsoffset);
154
155         nowner_sid_ptr->revision = owner_sid_ptr->revision;
156         nowner_sid_ptr->num_subauth = owner_sid_ptr->num_subauth;
157         for (i = 0; i < 6; i++)
158                 nowner_sid_ptr->authority[i] = owner_sid_ptr->authority[i];
159         for (i = 0; i < 5; i++)
160                 nowner_sid_ptr->sub_auth[i] = owner_sid_ptr->sub_auth[i];
161
162         /* copy group sid */
163         group_sid_ptr = (struct cifs_sid *)((char *)pntsd +
164                                 le32_to_cpu(pntsd->gsidoffset));
165         ngroup_sid_ptr = (struct cifs_sid *)((char *)pnntsd + sidsoffset +
166                                         sizeof(struct cifs_sid));
167
168         ngroup_sid_ptr->revision = group_sid_ptr->revision;
169         ngroup_sid_ptr->num_subauth = group_sid_ptr->num_subauth;
170         for (i = 0; i < 6; i++)
171                 ngroup_sid_ptr->authority[i] = group_sid_ptr->authority[i];
172         for (i = 0; i < 5; i++)
173                 ngroup_sid_ptr->sub_auth[i] =
174                                 cpu_to_le32(group_sid_ptr->sub_auth[i]);
175
176         return;
177 }
178
179
180 /*
181    change posix mode to reflect permissions
182    pmode is the existing mode (we only want to overwrite part of this
183    bits to set can be: S_IRWXU, S_IRWXG or S_IRWXO ie 00700 or 00070 or 00007
184 */
185 static void access_flags_to_mode(__le32 ace_flags, int type, umode_t *pmode,
186                                  umode_t *pbits_to_set)
187 {
188         __u32 flags = le32_to_cpu(ace_flags);
189         /* the order of ACEs is important.  The canonical order is to begin with
190            DENY entries followed by ALLOW, otherwise an allow entry could be
191            encountered first, making the subsequent deny entry like "dead code"
192            which would be superflous since Windows stops when a match is made
193            for the operation you are trying to perform for your user */
194
195         /* For deny ACEs we change the mask so that subsequent allow access
196            control entries do not turn on the bits we are denying */
197         if (type == ACCESS_DENIED) {
198                 if (flags & GENERIC_ALL) {
199                         *pbits_to_set &= ~S_IRWXUGO;
200                 }
201                 if ((flags & GENERIC_WRITE) ||
202                         ((flags & FILE_WRITE_RIGHTS) == FILE_WRITE_RIGHTS))
203                         *pbits_to_set &= ~S_IWUGO;
204                 if ((flags & GENERIC_READ) ||
205                         ((flags & FILE_READ_RIGHTS) == FILE_READ_RIGHTS))
206                         *pbits_to_set &= ~S_IRUGO;
207                 if ((flags & GENERIC_EXECUTE) ||
208                         ((flags & FILE_EXEC_RIGHTS) == FILE_EXEC_RIGHTS))
209                         *pbits_to_set &= ~S_IXUGO;
210                 return;
211         } else if (type != ACCESS_ALLOWED) {
212                 cERROR(1, ("unknown access control type %d", type));
213                 return;
214         }
215         /* else ACCESS_ALLOWED type */
216
217         if (flags & GENERIC_ALL) {
218                 *pmode |= (S_IRWXUGO & (*pbits_to_set));
219 #ifdef CONFIG_CIFS_DEBUG2
220                 cFYI(1, ("all perms"));
221 #endif
222                 return;
223         }
224         if ((flags & GENERIC_WRITE) ||
225                         ((flags & FILE_WRITE_RIGHTS) == FILE_WRITE_RIGHTS))
226                 *pmode |= (S_IWUGO & (*pbits_to_set));
227         if ((flags & GENERIC_READ) ||
228                         ((flags & FILE_READ_RIGHTS) == FILE_READ_RIGHTS))
229                 *pmode |= (S_IRUGO & (*pbits_to_set));
230         if ((flags & GENERIC_EXECUTE) ||
231                         ((flags & FILE_EXEC_RIGHTS) == FILE_EXEC_RIGHTS))
232                 *pmode |= (S_IXUGO & (*pbits_to_set));
233
234 #ifdef CONFIG_CIFS_DEBUG2
235         cFYI(1, ("access flags 0x%x mode now 0x%x", flags, *pmode));
236 #endif
237         return;
238 }
239
240 /*
241    Generate access flags to reflect permissions mode is the existing mode.
242    This function is called for every ACE in the DACL whose SID matches
243    with either owner or group or everyone.
244 */
245
246 static void mode_to_access_flags(umode_t mode, umode_t bits_to_use,
247                                 __u32 *pace_flags)
248 {
249         /* reset access mask */
250         *pace_flags = 0x0;
251
252         /* bits to use are either S_IRWXU or S_IRWXG or S_IRWXO */
253         mode &= bits_to_use;
254
255         /* check for R/W/X UGO since we do not know whose flags
256            is this but we have cleared all the bits sans RWX for
257            either user or group or other as per bits_to_use */
258         if (mode & S_IRUGO)
259                 *pace_flags |= SET_FILE_READ_RIGHTS;
260         if (mode & S_IWUGO)
261                 *pace_flags |= SET_FILE_WRITE_RIGHTS;
262         if (mode & S_IXUGO)
263                 *pace_flags |= SET_FILE_EXEC_RIGHTS;
264
265 #ifdef CONFIG_CIFS_DEBUG2
266         cFYI(1, ("mode: 0x%x, access flags now 0x%x", mode, *pace_flags));
267 #endif
268         return;
269 }
270
271 static __le16 fill_ace_for_sid(struct cifs_ace *pntace,
272                         const struct cifs_sid *psid, __u64 nmode, umode_t bits)
273 {
274         int i;
275         __u16 size = 0;
276         __u32 access_req = 0;
277
278         pntace->type = ACCESS_ALLOWED;
279         pntace->flags = 0x0;
280         mode_to_access_flags(nmode, bits, &access_req);
281         if (!access_req)
282                 access_req = SET_MINIMUM_RIGHTS;
283         pntace->access_req = cpu_to_le32(access_req);
284
285         pntace->sid.revision = psid->revision;
286         pntace->sid.num_subauth = psid->num_subauth;
287         for (i = 0; i < 6; i++)
288                 pntace->sid.authority[i] = psid->authority[i];
289         for (i = 0; i < psid->num_subauth; i++)
290                 pntace->sid.sub_auth[i] = psid->sub_auth[i];
291
292         size = 1 + 1 + 2 + 4 + 1 + 1 + 6 + (psid->num_subauth * 4);
293         pntace->size = cpu_to_le16(size);
294
295         return (size);
296 }
297
298
299 #ifdef CONFIG_CIFS_DEBUG2
300 static void dump_ace(struct cifs_ace *pace, char *end_of_acl)
301 {
302         int num_subauth;
303
304         /* validate that we do not go past end of acl */
305
306         if (le16_to_cpu(pace->size) < 16) {
307                 cERROR(1, ("ACE too small, %d", le16_to_cpu(pace->size)));
308                 return;
309         }
310
311         if (end_of_acl < (char *)pace + le16_to_cpu(pace->size)) {
312                 cERROR(1, ("ACL too small to parse ACE"));
313                 return;
314         }
315
316         num_subauth = pace->sid.num_subauth;
317         if (num_subauth) {
318                 int i;
319                 cFYI(1, ("ACE revision %d num_auth %d type %d flags %d size %d",
320                         pace->sid.revision, pace->sid.num_subauth, pace->type,
321                         pace->flags, le16_to_cpu(pace->size)));
322                 for (i = 0; i < num_subauth; ++i) {
323                         cFYI(1, ("ACE sub_auth[%d]: 0x%x", i,
324                                 le32_to_cpu(pace->sid.sub_auth[i])));
325                 }
326
327                 /* BB add length check to make sure that we do not have huge
328                         num auths and therefore go off the end */
329         }
330
331         return;
332 }
333 #endif
334
335
336 static void parse_dacl(struct cifs_acl *pdacl, char *end_of_acl,
337                        struct cifs_sid *pownersid, struct cifs_sid *pgrpsid,
338                        struct inode *inode)
339 {
340         int i;
341         int num_aces = 0;
342         int acl_size;
343         char *acl_base;
344         struct cifs_ace **ppace;
345
346         /* BB need to add parm so we can store the SID BB */
347
348         if (!pdacl) {
349                 /* no DACL in the security descriptor, set
350                    all the permissions for user/group/other */
351                 inode->i_mode |= S_IRWXUGO;
352                 return;
353         }
354
355         /* validate that we do not go past end of acl */
356         if (end_of_acl < (char *)pdacl + le16_to_cpu(pdacl->size)) {
357                 cERROR(1, ("ACL too small to parse DACL"));
358                 return;
359         }
360
361 #ifdef CONFIG_CIFS_DEBUG2
362         cFYI(1, ("DACL revision %d size %d num aces %d",
363                 le16_to_cpu(pdacl->revision), le16_to_cpu(pdacl->size),
364                 le32_to_cpu(pdacl->num_aces)));
365 #endif
366
367         /* reset rwx permissions for user/group/other.
368            Also, if num_aces is 0 i.e. DACL has no ACEs,
369            user/group/other have no permissions */
370         inode->i_mode &= ~(S_IRWXUGO);
371
372         acl_base = (char *)pdacl;
373         acl_size = sizeof(struct cifs_acl);
374
375         num_aces = le32_to_cpu(pdacl->num_aces);
376         if (num_aces  > 0) {
377                 umode_t user_mask = S_IRWXU;
378                 umode_t group_mask = S_IRWXG;
379                 umode_t other_mask = S_IRWXO;
380
381                 ppace = kmalloc(num_aces * sizeof(struct cifs_ace *),
382                                 GFP_KERNEL);
383
384 /*              cifscred->cecount = pdacl->num_aces;
385                 cifscred->aces = kmalloc(num_aces *
386                         sizeof(struct cifs_ace *), GFP_KERNEL);*/
387
388                 for (i = 0; i < num_aces; ++i) {
389                         ppace[i] = (struct cifs_ace *) (acl_base + acl_size);
390 #ifdef CONFIG_CIFS_DEBUG2
391                         dump_ace(ppace[i], end_of_acl);
392 #endif
393                         if (compare_sids(&(ppace[i]->sid), pownersid))
394                                 access_flags_to_mode(ppace[i]->access_req,
395                                                      ppace[i]->type,
396                                                      &(inode->i_mode),
397                                                      &user_mask);
398                         if (compare_sids(&(ppace[i]->sid), pgrpsid))
399                                 access_flags_to_mode(ppace[i]->access_req,
400                                                      ppace[i]->type,
401                                                      &(inode->i_mode),
402                                                      &group_mask);
403                         if (compare_sids(&(ppace[i]->sid), &sid_everyone))
404                                 access_flags_to_mode(ppace[i]->access_req,
405                                                      ppace[i]->type,
406                                                      &(inode->i_mode),
407                                                      &other_mask);
408
409 /*                      memcpy((void *)(&(cifscred->aces[i])),
410                                 (void *)ppace[i],
411                                 sizeof(struct cifs_ace)); */
412
413                         acl_base = (char *)ppace[i];
414                         acl_size = le16_to_cpu(ppace[i]->size);
415                 }
416
417                 kfree(ppace);
418         }
419
420         return;
421 }
422
423
424 static int set_chmod_dacl(struct cifs_acl *pndacl, struct cifs_sid *pownersid,
425                         struct cifs_sid *pgrpsid, __u64 nmode)
426 {
427         __le16 size = 0;
428         struct cifs_acl *pnndacl;
429
430         pnndacl = (struct cifs_acl *)((char *)pndacl + sizeof(struct cifs_acl));
431
432         size += fill_ace_for_sid((struct cifs_ace *) ((char *)pnndacl + size),
433                                         pownersid, nmode, S_IRWXU);
434         size += fill_ace_for_sid((struct cifs_ace *)((char *)pnndacl + size),
435                                         pgrpsid, nmode, S_IRWXG);
436         size += fill_ace_for_sid((struct cifs_ace *)((char *)pnndacl + size),
437                                          &sid_everyone, nmode, S_IRWXO);
438
439         pndacl->size = cpu_to_le16(size + sizeof(struct cifs_acl));
440         pndacl->num_aces = 3;
441
442         return (0);
443 }
444
445
446 static int parse_sid(struct cifs_sid *psid, char *end_of_acl)
447 {
448         /* BB need to add parm so we can store the SID BB */
449
450         /* validate that we do not go past end of ACL - sid must be at least 8
451            bytes long (assuming no sub-auths - e.g. the null SID */
452         if (end_of_acl < (char *)psid + 8) {
453                 cERROR(1, ("ACL too small to parse SID %p", psid));
454                 return -EINVAL;
455         }
456
457         if (psid->num_subauth) {
458 #ifdef CONFIG_CIFS_DEBUG2
459                 int i;
460                 cFYI(1, ("SID revision %d num_auth %d",
461                         psid->revision, psid->num_subauth));
462
463                 for (i = 0; i < psid->num_subauth; i++) {
464                         cFYI(1, ("SID sub_auth[%d]: 0x%x ", i,
465                                 le32_to_cpu(psid->sub_auth[i])));
466                 }
467
468                 /* BB add length check to make sure that we do not have huge
469                         num auths and therefore go off the end */
470                 cFYI(1, ("RID 0x%x",
471                         le32_to_cpu(psid->sub_auth[psid->num_subauth-1])));
472 #endif
473         }
474
475         return 0;
476 }
477
478
479 /* Convert CIFS ACL to POSIX form */
480 static int parse_sec_desc(struct cifs_ntsd *pntsd, int acl_len,
481                           struct inode *inode)
482 {
483         int rc;
484         struct cifs_sid *owner_sid_ptr, *group_sid_ptr;
485         struct cifs_acl *dacl_ptr; /* no need for SACL ptr */
486         char *end_of_acl = ((char *)pntsd) + acl_len;
487         __u32 dacloffset;
488
489         if ((inode == NULL) || (pntsd == NULL))
490                 return -EIO;
491
492         owner_sid_ptr = (struct cifs_sid *)((char *)pntsd +
493                                 le32_to_cpu(pntsd->osidoffset));
494         group_sid_ptr = (struct cifs_sid *)((char *)pntsd +
495                                 le32_to_cpu(pntsd->gsidoffset));
496         dacloffset = le32_to_cpu(pntsd->dacloffset);
497         dacl_ptr = (struct cifs_acl *)((char *)pntsd + dacloffset);
498 #ifdef CONFIG_CIFS_DEBUG2
499         cFYI(1, ("revision %d type 0x%x ooffset 0x%x goffset 0x%x "
500                  "sacloffset 0x%x dacloffset 0x%x",
501                  pntsd->revision, pntsd->type, le32_to_cpu(pntsd->osidoffset),
502                  le32_to_cpu(pntsd->gsidoffset),
503                  le32_to_cpu(pntsd->sacloffset), dacloffset));
504 #endif
505 /*      cifs_dump_mem("owner_sid: ", owner_sid_ptr, 64); */
506         rc = parse_sid(owner_sid_ptr, end_of_acl);
507         if (rc)
508                 return rc;
509
510         rc = parse_sid(group_sid_ptr, end_of_acl);
511         if (rc)
512                 return rc;
513
514         if (dacloffset)
515                 parse_dacl(dacl_ptr, end_of_acl, owner_sid_ptr,
516                            group_sid_ptr, inode);
517         else
518                 cFYI(1, ("no ACL")); /* BB grant all or default perms? */
519
520 /*      cifscred->uid = owner_sid_ptr->rid;
521         cifscred->gid = group_sid_ptr->rid;
522         memcpy((void *)(&(cifscred->osid)), (void *)owner_sid_ptr,
523                         sizeof(struct cifs_sid));
524         memcpy((void *)(&(cifscred->gsid)), (void *)group_sid_ptr,
525                         sizeof(struct cifs_sid)); */
526
527
528         return (0);
529 }
530
531
532 /* Convert permission bits from mode to equivalent CIFS ACL */
533 static int build_sec_desc(struct cifs_ntsd *pntsd, struct cifs_ntsd *pnntsd,
534                                 int acl_len, struct inode *inode, __u64 nmode)
535 {
536         int rc = 0;
537         __u32 dacloffset;
538         __u32 ndacloffset;
539         __u32 sidsoffset;
540         struct cifs_sid *owner_sid_ptr, *group_sid_ptr;
541         struct cifs_acl *dacl_ptr = NULL;  /* no need for SACL ptr */
542         struct cifs_acl *ndacl_ptr = NULL; /* no need for SACL ptr */
543
544         if ((inode == NULL) || (pntsd == NULL) || (pnntsd == NULL))
545                 return (-EIO);
546
547         owner_sid_ptr = (struct cifs_sid *)((char *)pntsd +
548                                 le32_to_cpu(pntsd->osidoffset));
549         group_sid_ptr = (struct cifs_sid *)((char *)pntsd +
550                                 le32_to_cpu(pntsd->gsidoffset));
551
552         dacloffset = le32_to_cpu(pntsd->dacloffset);
553         dacl_ptr = (struct cifs_acl *)((char *)pntsd + dacloffset);
554
555         ndacloffset = sizeof(struct cifs_ntsd);
556         ndacl_ptr = (struct cifs_acl *)((char *)pnntsd + ndacloffset);
557         ndacl_ptr->revision = dacl_ptr->revision;
558         ndacl_ptr->size = 0;
559         ndacl_ptr->num_aces = 0;
560
561         rc = set_chmod_dacl(ndacl_ptr, owner_sid_ptr, group_sid_ptr, nmode);
562
563         sidsoffset = ndacloffset + le16_to_cpu(ndacl_ptr->size);
564
565         /* copy security descriptor control portion and owner and group sid */
566         copy_sec_desc(pntsd, pnntsd, sidsoffset);
567
568         return (rc);
569 }
570
571
572 /* Retrieve an ACL from the server */
573 static struct cifs_ntsd *get_cifs_acl(u32 *pacllen, struct inode *inode,
574                                        const char *path)
575 {
576         struct cifsFileInfo *open_file;
577         int unlock_file = FALSE;
578         int xid;
579         int rc = -EIO;
580         __u16 fid;
581         struct super_block *sb;
582         struct cifs_sb_info *cifs_sb;
583         struct cifs_ntsd *pntsd = NULL;
584
585         cFYI(1, ("get mode from ACL for %s", path));
586
587         if (inode == NULL)
588                 return NULL;
589
590         xid = GetXid();
591         open_file = find_readable_file(CIFS_I(inode));
592         sb = inode->i_sb;
593         if (sb == NULL) {
594                 FreeXid(xid);
595                 return NULL;
596         }
597         cifs_sb = CIFS_SB(sb);
598
599         if (open_file) {
600                 unlock_file = TRUE;
601                 fid = open_file->netfid;
602         } else {
603                 int oplock = FALSE;
604                 /* open file */
605                 rc = CIFSSMBOpen(xid, cifs_sb->tcon, path, FILE_OPEN,
606                                 READ_CONTROL, 0, &fid, &oplock, NULL,
607                                 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
608                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
609                 if (rc != 0) {
610                         cERROR(1, ("Unable to open file to get ACL"));
611                         FreeXid(xid);
612                         return NULL;
613                 }
614         }
615
616         rc = CIFSSMBGetCIFSACL(xid, cifs_sb->tcon, fid, &pntsd, pacllen);
617         cFYI(1, ("GetCIFSACL rc = %d ACL len %d", rc, *pacllen));
618         if (unlock_file == TRUE)
619                 atomic_dec(&open_file->wrtPending);
620         else
621                 CIFSSMBClose(xid, cifs_sb->tcon, fid);
622
623         FreeXid(xid);
624         return pntsd;
625 }
626
627 /* Set an ACL on the server */
628 static int set_cifs_acl(struct cifs_ntsd *pnntsd, __u32 acllen,
629                                 struct inode *inode, const char *path)
630 {
631         struct cifsFileInfo *open_file;
632         int unlock_file = FALSE;
633         int xid;
634         int rc = -EIO;
635         __u16 fid;
636         struct super_block *sb;
637         struct cifs_sb_info *cifs_sb;
638
639 #ifdef CONFIG_CIFS_DEBUG2
640         cFYI(1, ("set ACL for %s from mode 0x%x", path, inode->i_mode));
641 #endif
642
643         if (!inode)
644                 return (rc);
645
646         sb = inode->i_sb;
647         if (sb == NULL)
648                 return (rc);
649
650         cifs_sb = CIFS_SB(sb);
651         xid = GetXid();
652
653         open_file = find_readable_file(CIFS_I(inode));
654         if (open_file) {
655                 unlock_file = TRUE;
656                 fid = open_file->netfid;
657         } else {
658                 int oplock = FALSE;
659                 /* open file */
660                 rc = CIFSSMBOpen(xid, cifs_sb->tcon, path, FILE_OPEN,
661                                 WRITE_DAC, 0, &fid, &oplock, NULL,
662                                 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
663                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
664                 if (rc != 0) {
665                         cERROR(1, ("Unable to open file to set ACL"));
666                         FreeXid(xid);
667                         return (rc);
668                 }
669         }
670
671         rc = CIFSSMBSetCIFSACL(xid, cifs_sb->tcon, fid, pnntsd, acllen);
672 #ifdef CONFIG_CIFS_DEBUG2
673         cFYI(1, ("SetCIFSACL rc = %d", rc));
674 #endif
675         if (unlock_file == TRUE)
676                 atomic_dec(&open_file->wrtPending);
677         else
678                 CIFSSMBClose(xid, cifs_sb->tcon, fid);
679
680         FreeXid(xid);
681
682         return (rc);
683 }
684
685 /* Translate the CIFS ACL (simlar to NTFS ACL) for a file into mode bits */
686 void acl_to_uid_mode(struct inode *inode, const char *path)
687 {
688         struct cifs_ntsd *pntsd = NULL;
689         u32 acllen = 0;
690         int rc = 0;
691
692 #ifdef CONFIG_CIFS_DEBUG2
693         cFYI(1, ("converting ACL to mode for %s", path));
694 #endif
695         pntsd = get_cifs_acl(&acllen, inode, path);
696
697         /* if we can retrieve the ACL, now parse Access Control Entries, ACEs */
698         if (pntsd)
699                 rc = parse_sec_desc(pntsd, acllen, inode);
700         if (rc)
701                 cFYI(1, ("parse sec desc failed rc = %d", rc));
702
703         kfree(pntsd);
704         return;
705 }
706
707 /* Convert mode bits to an ACL so we can update the ACL on the server */
708 int mode_to_acl(struct inode *inode, const char *path, __u64 nmode)
709 {
710         int rc = 0;
711         __u32 acllen = 0;
712         struct cifs_ntsd *pntsd = NULL; /* acl obtained from server */
713         struct cifs_ntsd *pnntsd = NULL; /* modified acl to be sent to server */
714
715 #ifdef CONFIG_CIFS_DEBUG2
716         cFYI(1, ("set ACL from mode for %s", path));
717 #endif
718
719         /* Get the security descriptor */
720         pntsd = get_cifs_acl(&acllen, inode, path);
721
722         /* Add three ACEs for owner, group, everyone getting rid of
723            other ACEs as chmod disables ACEs and set the security descriptor */
724
725         if (pntsd) {
726                 /* allocate memory for the smb header,
727                    set security descriptor request security descriptor
728                    parameters, and secuirty descriptor itself */
729
730                 pnntsd = kmalloc(acllen, GFP_KERNEL);
731                 if (!pnntsd) {
732                         cERROR(1, ("Unable to allocate security descriptor"));
733                         kfree(pntsd);
734                         return (-ENOMEM);
735                 }
736
737                 rc = build_sec_desc(pntsd, pnntsd, acllen, inode, nmode);
738
739 #ifdef CONFIG_CIFS_DEBUG2
740                 cFYI(1, ("build_sec_desc rc: %d", rc));
741 #endif
742
743                 if (!rc) {
744                         /* Set the security descriptor */
745                         rc = set_cifs_acl(pnntsd, acllen, inode, path);
746 #ifdef CONFIG_CIFS_DEBUG2
747                         cFYI(1, ("set_cifs_acl rc: %d", rc));
748 #endif
749                 }
750
751                 kfree(pnntsd);
752                 kfree(pntsd);
753         }
754
755         return (rc);
756 }
757 #endif /* CONFIG_CIFS_EXPERIMENTAL */