nfs4acl.c 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856
  1. /*
  2. * fs/nfs4acl/acl.c
  3. *
  4. * Common NFSv4 ACL handling code.
  5. *
  6. * Copyright (c) 2002, 2003 The Regents of the University of Michigan.
  7. * All rights reserved.
  8. *
  9. * Marius Aamodt Eriksen <marius@umich.edu>
  10. * Jeff Sedlak <jsedlak@umich.edu>
  11. * J. Bruce Fields <bfields@umich.edu>
  12. *
  13. * Redistribution and use in source and binary forms, with or without
  14. * modification, are permitted provided that the following conditions
  15. * are met:
  16. *
  17. * 1. Redistributions of source code must retain the above copyright
  18. * notice, this list of conditions and the following disclaimer.
  19. * 2. Redistributions in binary form must reproduce the above copyright
  20. * notice, this list of conditions and the following disclaimer in the
  21. * documentation and/or other materials provided with the distribution.
  22. * 3. Neither the name of the University nor the names of its
  23. * contributors may be used to endorse or promote products derived
  24. * from this software without specific prior written permission.
  25. *
  26. * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  27. * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  28. * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  29. * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  30. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  31. * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  32. * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  33. * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  34. * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  35. * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  36. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  37. */
  38. #include <linux/string.h>
  39. #include <linux/slab.h>
  40. #include <linux/list.h>
  41. #include <linux/types.h>
  42. #include <linux/fs.h>
  43. #include <linux/module.h>
  44. #include <linux/nfs_fs.h>
  45. #include <linux/posix_acl.h>
  46. #include <linux/nfs4.h>
  47. #include <linux/nfs4_acl.h>
  48. /* mode bit translations: */
  49. #define NFS4_READ_MODE (NFS4_ACE_READ_DATA)
  50. #define NFS4_WRITE_MODE (NFS4_ACE_WRITE_DATA | NFS4_ACE_APPEND_DATA)
  51. #define NFS4_EXECUTE_MODE NFS4_ACE_EXECUTE
  52. #define NFS4_ANYONE_MODE (NFS4_ACE_READ_ATTRIBUTES | NFS4_ACE_READ_ACL | NFS4_ACE_SYNCHRONIZE)
  53. #define NFS4_OWNER_MODE (NFS4_ACE_WRITE_ATTRIBUTES | NFS4_ACE_WRITE_ACL)
  54. /* We don't support these bits; insist they be neither allowed nor denied */
  55. #define NFS4_MASK_UNSUPP (NFS4_ACE_DELETE | NFS4_ACE_WRITE_OWNER \
  56. | NFS4_ACE_READ_NAMED_ATTRS | NFS4_ACE_WRITE_NAMED_ATTRS)
  57. /* flags used to simulate posix default ACLs */
  58. #define NFS4_INHERITANCE_FLAGS (NFS4_ACE_FILE_INHERIT_ACE \
  59. | NFS4_ACE_DIRECTORY_INHERIT_ACE)
  60. #define NFS4_SUPPORTED_FLAGS (NFS4_INHERITANCE_FLAGS \
  61. | NFS4_ACE_INHERIT_ONLY_ACE \
  62. | NFS4_ACE_IDENTIFIER_GROUP)
  63. #define MASK_EQUAL(mask1, mask2) \
  64. ( ((mask1) & NFS4_ACE_MASK_ALL) == ((mask2) & NFS4_ACE_MASK_ALL) )
  65. static u32
  66. mask_from_posix(unsigned short perm, unsigned int flags)
  67. {
  68. int mask = NFS4_ANYONE_MODE;
  69. if (flags & NFS4_ACL_OWNER)
  70. mask |= NFS4_OWNER_MODE;
  71. if (perm & ACL_READ)
  72. mask |= NFS4_READ_MODE;
  73. if (perm & ACL_WRITE)
  74. mask |= NFS4_WRITE_MODE;
  75. if ((perm & ACL_WRITE) && (flags & NFS4_ACL_DIR))
  76. mask |= NFS4_ACE_DELETE_CHILD;
  77. if (perm & ACL_EXECUTE)
  78. mask |= NFS4_EXECUTE_MODE;
  79. return mask;
  80. }
  81. static u32
  82. deny_mask_from_posix(unsigned short perm, u32 flags)
  83. {
  84. u32 mask = 0;
  85. if (perm & ACL_READ)
  86. mask |= NFS4_READ_MODE;
  87. if (perm & ACL_WRITE)
  88. mask |= NFS4_WRITE_MODE;
  89. if ((perm & ACL_WRITE) && (flags & NFS4_ACL_DIR))
  90. mask |= NFS4_ACE_DELETE_CHILD;
  91. if (perm & ACL_EXECUTE)
  92. mask |= NFS4_EXECUTE_MODE;
  93. return mask;
  94. }
  95. /* XXX: modify functions to return NFS errors; they're only ever
  96. * used by nfs code, after all.... */
  97. /* We only map from NFSv4 to POSIX ACLs when setting ACLs, when we err on the
  98. * side of being more restrictive, so the mode bit mapping below is
  99. * pessimistic. An optimistic version would be needed to handle DENY's,
  100. * but we espect to coalesce all ALLOWs and DENYs before mapping to mode
  101. * bits. */
  102. static void
  103. low_mode_from_nfs4(u32 perm, unsigned short *mode, unsigned int flags)
  104. {
  105. u32 write_mode = NFS4_WRITE_MODE;
  106. if (flags & NFS4_ACL_DIR)
  107. write_mode |= NFS4_ACE_DELETE_CHILD;
  108. *mode = 0;
  109. if ((perm & NFS4_READ_MODE) == NFS4_READ_MODE)
  110. *mode |= ACL_READ;
  111. if ((perm & write_mode) == write_mode)
  112. *mode |= ACL_WRITE;
  113. if ((perm & NFS4_EXECUTE_MODE) == NFS4_EXECUTE_MODE)
  114. *mode |= ACL_EXECUTE;
  115. }
  116. struct ace_container {
  117. struct nfs4_ace *ace;
  118. struct list_head ace_l;
  119. };
  120. static short ace2type(struct nfs4_ace *);
  121. static void _posix_to_nfsv4_one(struct posix_acl *, struct nfs4_acl *,
  122. unsigned int);
  123. void nfs4_acl_add_ace(struct nfs4_acl *, u32, u32, u32, int, uid_t);
  124. struct nfs4_acl *
  125. nfs4_acl_posix_to_nfsv4(struct posix_acl *pacl, struct posix_acl *dpacl,
  126. unsigned int flags)
  127. {
  128. struct nfs4_acl *acl;
  129. int size = 0;
  130. if (pacl) {
  131. if (posix_acl_valid(pacl) < 0)
  132. return ERR_PTR(-EINVAL);
  133. size += 2*pacl->a_count;
  134. }
  135. if (dpacl) {
  136. if (posix_acl_valid(dpacl) < 0)
  137. return ERR_PTR(-EINVAL);
  138. size += 2*dpacl->a_count;
  139. }
  140. /* Allocate for worst case: one (deny, allow) pair each: */
  141. acl = nfs4_acl_new(size);
  142. if (acl == NULL)
  143. return ERR_PTR(-ENOMEM);
  144. if (pacl)
  145. _posix_to_nfsv4_one(pacl, acl, flags & ~NFS4_ACL_TYPE_DEFAULT);
  146. if (dpacl)
  147. _posix_to_nfsv4_one(dpacl, acl, flags | NFS4_ACL_TYPE_DEFAULT);
  148. return acl;
  149. }
  150. struct posix_acl_summary {
  151. unsigned short owner;
  152. unsigned short users;
  153. unsigned short group;
  154. unsigned short groups;
  155. unsigned short other;
  156. unsigned short mask;
  157. };
  158. static void
  159. summarize_posix_acl(struct posix_acl *acl, struct posix_acl_summary *pas)
  160. {
  161. struct posix_acl_entry *pa, *pe;
  162. pas->users = 0;
  163. pas->groups = 0;
  164. pas->mask = 07;
  165. pe = acl->a_entries + acl->a_count;
  166. FOREACH_ACL_ENTRY(pa, acl, pe) {
  167. switch (pa->e_tag) {
  168. case ACL_USER_OBJ:
  169. pas->owner = pa->e_perm;
  170. break;
  171. case ACL_GROUP_OBJ:
  172. pas->group = pa->e_perm;
  173. break;
  174. case ACL_USER:
  175. pas->users |= pa->e_perm;
  176. break;
  177. case ACL_GROUP:
  178. pas->groups |= pa->e_perm;
  179. break;
  180. case ACL_OTHER:
  181. pas->other = pa->e_perm;
  182. break;
  183. case ACL_MASK:
  184. pas->mask = pa->e_perm;
  185. break;
  186. }
  187. }
  188. /* We'll only care about effective permissions: */
  189. pas->users &= pas->mask;
  190. pas->group &= pas->mask;
  191. pas->groups &= pas->mask;
  192. }
  193. /* We assume the acl has been verified with posix_acl_valid. */
  194. static void
  195. _posix_to_nfsv4_one(struct posix_acl *pacl, struct nfs4_acl *acl,
  196. unsigned int flags)
  197. {
  198. struct posix_acl_entry *pa, *group_owner_entry;
  199. struct nfs4_ace *ace;
  200. struct posix_acl_summary pas;
  201. unsigned short deny;
  202. int eflag = ((flags & NFS4_ACL_TYPE_DEFAULT) ?
  203. NFS4_INHERITANCE_FLAGS | NFS4_ACE_INHERIT_ONLY_ACE : 0);
  204. BUG_ON(pacl->a_count < 3);
  205. summarize_posix_acl(pacl, &pas);
  206. pa = pacl->a_entries;
  207. ace = acl->aces + acl->naces;
  208. /* We could deny everything not granted by the owner: */
  209. deny = ~pas.owner;
  210. /*
  211. * but it is equivalent (and simpler) to deny only what is not
  212. * granted by later entries:
  213. */
  214. deny &= pas.users | pas.group | pas.groups | pas.other;
  215. if (deny) {
  216. ace->type = NFS4_ACE_ACCESS_DENIED_ACE_TYPE;
  217. ace->flag = eflag;
  218. ace->access_mask = deny_mask_from_posix(deny, flags);
  219. ace->whotype = NFS4_ACL_WHO_OWNER;
  220. ace++;
  221. acl->naces++;
  222. }
  223. ace->type = NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE;
  224. ace->flag = eflag;
  225. ace->access_mask = mask_from_posix(pa->e_perm, flags | NFS4_ACL_OWNER);
  226. ace->whotype = NFS4_ACL_WHO_OWNER;
  227. ace++;
  228. acl->naces++;
  229. pa++;
  230. while (pa->e_tag == ACL_USER) {
  231. deny = ~(pa->e_perm & pas.mask);
  232. deny &= pas.groups | pas.group | pas.other;
  233. if (deny) {
  234. ace->type = NFS4_ACE_ACCESS_DENIED_ACE_TYPE;
  235. ace->flag = eflag;
  236. ace->access_mask = deny_mask_from_posix(deny, flags);
  237. ace->whotype = NFS4_ACL_WHO_NAMED;
  238. ace->who = pa->e_id;
  239. ace++;
  240. acl->naces++;
  241. }
  242. ace->type = NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE;
  243. ace->flag = eflag;
  244. ace->access_mask = mask_from_posix(pa->e_perm & pas.mask,
  245. flags);
  246. ace->whotype = NFS4_ACL_WHO_NAMED;
  247. ace->who = pa->e_id;
  248. ace++;
  249. acl->naces++;
  250. pa++;
  251. }
  252. /* In the case of groups, we apply allow ACEs first, then deny ACEs,
  253. * since a user can be in more than one group. */
  254. /* allow ACEs */
  255. group_owner_entry = pa;
  256. ace->type = NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE;
  257. ace->flag = eflag;
  258. ace->access_mask = mask_from_posix(pas.group, flags);
  259. ace->whotype = NFS4_ACL_WHO_GROUP;
  260. ace++;
  261. acl->naces++;
  262. pa++;
  263. while (pa->e_tag == ACL_GROUP) {
  264. ace->type = NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE;
  265. ace->flag = eflag | NFS4_ACE_IDENTIFIER_GROUP;
  266. ace->access_mask = mask_from_posix(pa->e_perm & pas.mask,
  267. flags);
  268. ace->whotype = NFS4_ACL_WHO_NAMED;
  269. ace->who = pa->e_id;
  270. ace++;
  271. acl->naces++;
  272. pa++;
  273. }
  274. /* deny ACEs */
  275. pa = group_owner_entry;
  276. deny = ~pas.group & pas.other;
  277. if (deny) {
  278. ace->type = NFS4_ACE_ACCESS_DENIED_ACE_TYPE;
  279. ace->flag = eflag | NFS4_ACE_IDENTIFIER_GROUP;
  280. ace->access_mask = deny_mask_from_posix(deny, flags);
  281. ace->whotype = NFS4_ACL_WHO_GROUP;
  282. ace++;
  283. acl->naces++;
  284. }
  285. pa++;
  286. while (pa->e_tag == ACL_GROUP) {
  287. deny = ~(pa->e_perm & pas.mask);
  288. deny &= pas.other;
  289. if (deny) {
  290. ace->type = NFS4_ACE_ACCESS_DENIED_ACE_TYPE;
  291. ace->flag = eflag | NFS4_ACE_IDENTIFIER_GROUP;
  292. ace->access_mask = mask_from_posix(deny, flags);
  293. ace->whotype = NFS4_ACL_WHO_NAMED;
  294. ace->who = pa->e_id;
  295. ace++;
  296. acl->naces++;
  297. }
  298. pa++;
  299. }
  300. if (pa->e_tag == ACL_MASK)
  301. pa++;
  302. ace->type = NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE;
  303. ace->flag = eflag;
  304. ace->access_mask = mask_from_posix(pa->e_perm, flags);
  305. ace->whotype = NFS4_ACL_WHO_EVERYONE;
  306. acl->naces++;
  307. }
  308. static void
  309. sort_pacl_range(struct posix_acl *pacl, int start, int end) {
  310. int sorted = 0, i;
  311. struct posix_acl_entry tmp;
  312. /* We just do a bubble sort; easy to do in place, and we're not
  313. * expecting acl's to be long enough to justify anything more. */
  314. while (!sorted) {
  315. sorted = 1;
  316. for (i = start; i < end; i++) {
  317. if (pacl->a_entries[i].e_id
  318. > pacl->a_entries[i+1].e_id) {
  319. sorted = 0;
  320. tmp = pacl->a_entries[i];
  321. pacl->a_entries[i] = pacl->a_entries[i+1];
  322. pacl->a_entries[i+1] = tmp;
  323. }
  324. }
  325. }
  326. }
  327. static void
  328. sort_pacl(struct posix_acl *pacl)
  329. {
  330. /* posix_acl_valid requires that users and groups be in order
  331. * by uid/gid. */
  332. int i, j;
  333. if (pacl->a_count <= 4)
  334. return; /* no users or groups */
  335. i = 1;
  336. while (pacl->a_entries[i].e_tag == ACL_USER)
  337. i++;
  338. sort_pacl_range(pacl, 1, i-1);
  339. BUG_ON(pacl->a_entries[i].e_tag != ACL_GROUP_OBJ);
  340. j = i++;
  341. while (pacl->a_entries[j].e_tag == ACL_GROUP)
  342. j++;
  343. sort_pacl_range(pacl, i, j-1);
  344. return;
  345. }
  346. /*
  347. * While processing the NFSv4 ACE, this maintains bitmasks representing
  348. * which permission bits have been allowed and which denied to a given
  349. * entity: */
  350. struct posix_ace_state {
  351. u32 allow;
  352. u32 deny;
  353. };
  354. struct posix_user_ace_state {
  355. uid_t uid;
  356. struct posix_ace_state perms;
  357. };
  358. struct posix_ace_state_array {
  359. int n;
  360. struct posix_user_ace_state aces[];
  361. };
  362. /*
  363. * While processing the NFSv4 ACE, this maintains the partial permissions
  364. * calculated so far: */
  365. struct posix_acl_state {
  366. int empty;
  367. struct posix_ace_state owner;
  368. struct posix_ace_state group;
  369. struct posix_ace_state other;
  370. struct posix_ace_state everyone;
  371. struct posix_ace_state mask; /* Deny unused in this case */
  372. struct posix_ace_state_array *users;
  373. struct posix_ace_state_array *groups;
  374. };
  375. static int
  376. init_state(struct posix_acl_state *state, int cnt)
  377. {
  378. int alloc;
  379. memset(state, 0, sizeof(struct posix_acl_state));
  380. state->empty = 1;
  381. /*
  382. * In the worst case, each individual acl could be for a distinct
  383. * named user or group, but we don't no which, so we allocate
  384. * enough space for either:
  385. */
  386. alloc = sizeof(struct posix_ace_state_array)
  387. + cnt*sizeof(struct posix_ace_state);
  388. state->users = kzalloc(alloc, GFP_KERNEL);
  389. if (!state->users)
  390. return -ENOMEM;
  391. state->groups = kzalloc(alloc, GFP_KERNEL);
  392. if (!state->groups) {
  393. kfree(state->users);
  394. return -ENOMEM;
  395. }
  396. return 0;
  397. }
  398. static void
  399. free_state(struct posix_acl_state *state) {
  400. kfree(state->users);
  401. kfree(state->groups);
  402. }
  403. static inline void add_to_mask(struct posix_acl_state *state, struct posix_ace_state *astate)
  404. {
  405. state->mask.allow |= astate->allow;
  406. }
  407. /*
  408. * Certain bits (SYNCHRONIZE, DELETE, WRITE_OWNER, READ/WRITE_NAMED_ATTRS,
  409. * READ_ATTRIBUTES, READ_ACL) are currently unenforceable and don't translate
  410. * to traditional read/write/execute permissions.
  411. *
  412. * It's problematic to reject acls that use certain mode bits, because it
  413. * places the burden on users to learn the rules about which bits one
  414. * particular server sets, without giving the user a lot of help--we return an
  415. * error that could mean any number of different things. To make matters
  416. * worse, the problematic bits might be introduced by some application that's
  417. * automatically mapping from some other acl model.
  418. *
  419. * So wherever possible we accept anything, possibly erring on the side of
  420. * denying more permissions than necessary.
  421. *
  422. * However we do reject *explicit* DENY's of a few bits representing
  423. * permissions we could never deny:
  424. */
  425. static inline int check_deny(u32 mask, int isowner)
  426. {
  427. if (mask & (NFS4_ACE_READ_ATTRIBUTES | NFS4_ACE_READ_ACL))
  428. return -EINVAL;
  429. if (!isowner)
  430. return 0;
  431. if (mask & (NFS4_ACE_WRITE_ATTRIBUTES | NFS4_ACE_WRITE_ACL))
  432. return -EINVAL;
  433. return 0;
  434. }
  435. static struct posix_acl *
  436. posix_state_to_acl(struct posix_acl_state *state, unsigned int flags)
  437. {
  438. struct posix_acl_entry *pace;
  439. struct posix_acl *pacl;
  440. int nace;
  441. int i, error = 0;
  442. /*
  443. * ACLs with no ACEs are treated differently in the inheritable
  444. * and effective cases: when there are no inheritable ACEs, we
  445. * set a zero-length default posix acl:
  446. */
  447. if (state->empty && (flags & NFS4_ACL_TYPE_DEFAULT)) {
  448. pacl = posix_acl_alloc(0, GFP_KERNEL);
  449. return pacl ? pacl : ERR_PTR(-ENOMEM);
  450. }
  451. /*
  452. * When there are no effective ACEs, the following will end
  453. * up setting a 3-element effective posix ACL with all
  454. * permissions zero.
  455. */
  456. nace = 4 + state->users->n + state->groups->n;
  457. pacl = posix_acl_alloc(nace, GFP_KERNEL);
  458. if (!pacl)
  459. return ERR_PTR(-ENOMEM);
  460. pace = pacl->a_entries;
  461. pace->e_tag = ACL_USER_OBJ;
  462. error = check_deny(state->owner.deny, 1);
  463. if (error)
  464. goto out_err;
  465. low_mode_from_nfs4(state->owner.allow, &pace->e_perm, flags);
  466. pace->e_id = ACL_UNDEFINED_ID;
  467. for (i=0; i < state->users->n; i++) {
  468. pace++;
  469. pace->e_tag = ACL_USER;
  470. error = check_deny(state->users->aces[i].perms.deny, 0);
  471. if (error)
  472. goto out_err;
  473. low_mode_from_nfs4(state->users->aces[i].perms.allow,
  474. &pace->e_perm, flags);
  475. pace->e_id = state->users->aces[i].uid;
  476. add_to_mask(state, &state->users->aces[i].perms);
  477. }
  478. pace++;
  479. pace->e_tag = ACL_GROUP_OBJ;
  480. error = check_deny(state->group.deny, 0);
  481. if (error)
  482. goto out_err;
  483. low_mode_from_nfs4(state->group.allow, &pace->e_perm, flags);
  484. pace->e_id = ACL_UNDEFINED_ID;
  485. add_to_mask(state, &state->group);
  486. for (i=0; i < state->groups->n; i++) {
  487. pace++;
  488. pace->e_tag = ACL_GROUP;
  489. error = check_deny(state->groups->aces[i].perms.deny, 0);
  490. if (error)
  491. goto out_err;
  492. low_mode_from_nfs4(state->groups->aces[i].perms.allow,
  493. &pace->e_perm, flags);
  494. pace->e_id = state->groups->aces[i].uid;
  495. add_to_mask(state, &state->groups->aces[i].perms);
  496. }
  497. pace++;
  498. pace->e_tag = ACL_MASK;
  499. low_mode_from_nfs4(state->mask.allow, &pace->e_perm, flags);
  500. pace->e_id = ACL_UNDEFINED_ID;
  501. pace++;
  502. pace->e_tag = ACL_OTHER;
  503. error = check_deny(state->other.deny, 0);
  504. if (error)
  505. goto out_err;
  506. low_mode_from_nfs4(state->other.allow, &pace->e_perm, flags);
  507. pace->e_id = ACL_UNDEFINED_ID;
  508. return pacl;
  509. out_err:
  510. posix_acl_release(pacl);
  511. return ERR_PTR(error);
  512. }
  513. static inline void allow_bits(struct posix_ace_state *astate, u32 mask)
  514. {
  515. /* Allow all bits in the mask not already denied: */
  516. astate->allow |= mask & ~astate->deny;
  517. }
  518. static inline void deny_bits(struct posix_ace_state *astate, u32 mask)
  519. {
  520. /* Deny all bits in the mask not already allowed: */
  521. astate->deny |= mask & ~astate->allow;
  522. }
  523. static int find_uid(struct posix_acl_state *state, struct posix_ace_state_array *a, uid_t uid)
  524. {
  525. int i;
  526. for (i = 0; i < a->n; i++)
  527. if (a->aces[i].uid == uid)
  528. return i;
  529. /* Not found: */
  530. a->n++;
  531. a->aces[i].uid = uid;
  532. a->aces[i].perms.allow = state->everyone.allow;
  533. a->aces[i].perms.deny = state->everyone.deny;
  534. return i;
  535. }
  536. static void deny_bits_array(struct posix_ace_state_array *a, u32 mask)
  537. {
  538. int i;
  539. for (i=0; i < a->n; i++)
  540. deny_bits(&a->aces[i].perms, mask);
  541. }
  542. static void allow_bits_array(struct posix_ace_state_array *a, u32 mask)
  543. {
  544. int i;
  545. for (i=0; i < a->n; i++)
  546. allow_bits(&a->aces[i].perms, mask);
  547. }
  548. static void process_one_v4_ace(struct posix_acl_state *state,
  549. struct nfs4_ace *ace)
  550. {
  551. u32 mask = ace->access_mask;
  552. int i;
  553. state->empty = 0;
  554. switch (ace2type(ace)) {
  555. case ACL_USER_OBJ:
  556. if (ace->type == NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE) {
  557. allow_bits(&state->owner, mask);
  558. } else {
  559. deny_bits(&state->owner, mask);
  560. }
  561. break;
  562. case ACL_USER:
  563. i = find_uid(state, state->users, ace->who);
  564. if (ace->type == NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE) {
  565. allow_bits(&state->users->aces[i].perms, mask);
  566. } else {
  567. deny_bits(&state->users->aces[i].perms, mask);
  568. mask = state->users->aces[i].perms.deny;
  569. deny_bits(&state->owner, mask);
  570. }
  571. break;
  572. case ACL_GROUP_OBJ:
  573. if (ace->type == NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE) {
  574. allow_bits(&state->group, mask);
  575. } else {
  576. deny_bits(&state->group, mask);
  577. mask = state->group.deny;
  578. deny_bits(&state->owner, mask);
  579. deny_bits(&state->everyone, mask);
  580. deny_bits_array(state->users, mask);
  581. deny_bits_array(state->groups, mask);
  582. }
  583. break;
  584. case ACL_GROUP:
  585. i = find_uid(state, state->groups, ace->who);
  586. if (ace->type == NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE) {
  587. allow_bits(&state->groups->aces[i].perms, mask);
  588. } else {
  589. deny_bits(&state->groups->aces[i].perms, mask);
  590. mask = state->groups->aces[i].perms.deny;
  591. deny_bits(&state->owner, mask);
  592. deny_bits(&state->group, mask);
  593. deny_bits(&state->everyone, mask);
  594. deny_bits_array(state->users, mask);
  595. deny_bits_array(state->groups, mask);
  596. }
  597. break;
  598. case ACL_OTHER:
  599. if (ace->type == NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE) {
  600. allow_bits(&state->owner, mask);
  601. allow_bits(&state->group, mask);
  602. allow_bits(&state->other, mask);
  603. allow_bits(&state->everyone, mask);
  604. allow_bits_array(state->users, mask);
  605. allow_bits_array(state->groups, mask);
  606. } else {
  607. deny_bits(&state->owner, mask);
  608. deny_bits(&state->group, mask);
  609. deny_bits(&state->other, mask);
  610. deny_bits(&state->everyone, mask);
  611. deny_bits_array(state->users, mask);
  612. deny_bits_array(state->groups, mask);
  613. }
  614. }
  615. }
  616. int nfs4_acl_nfsv4_to_posix(struct nfs4_acl *acl, struct posix_acl **pacl,
  617. struct posix_acl **dpacl, unsigned int flags)
  618. {
  619. struct posix_acl_state effective_acl_state, default_acl_state;
  620. struct nfs4_ace *ace;
  621. int ret;
  622. ret = init_state(&effective_acl_state, acl->naces);
  623. if (ret)
  624. return ret;
  625. ret = init_state(&default_acl_state, acl->naces);
  626. if (ret)
  627. goto out_estate;
  628. ret = -EINVAL;
  629. for (ace = acl->aces; ace < acl->aces + acl->naces; ace++) {
  630. if (ace->type != NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE &&
  631. ace->type != NFS4_ACE_ACCESS_DENIED_ACE_TYPE)
  632. goto out_dstate;
  633. if (ace->flag & ~NFS4_SUPPORTED_FLAGS)
  634. goto out_dstate;
  635. if ((ace->flag & NFS4_INHERITANCE_FLAGS) == 0) {
  636. process_one_v4_ace(&effective_acl_state, ace);
  637. continue;
  638. }
  639. if (!(flags & NFS4_ACL_DIR))
  640. goto out_dstate;
  641. /*
  642. * Note that when only one of FILE_INHERIT or DIRECTORY_INHERIT
  643. * is set, we're effectively turning on the other. That's OK,
  644. * according to rfc 3530.
  645. */
  646. process_one_v4_ace(&default_acl_state, ace);
  647. if (!(ace->flag & NFS4_ACE_INHERIT_ONLY_ACE))
  648. process_one_v4_ace(&effective_acl_state, ace);
  649. }
  650. *pacl = posix_state_to_acl(&effective_acl_state, flags);
  651. if (IS_ERR(*pacl)) {
  652. ret = PTR_ERR(*pacl);
  653. goto out_dstate;
  654. }
  655. *dpacl = posix_state_to_acl(&default_acl_state,
  656. flags | NFS4_ACL_TYPE_DEFAULT);
  657. if (IS_ERR(*dpacl)) {
  658. ret = PTR_ERR(*dpacl);
  659. posix_acl_release(*pacl);
  660. goto out_dstate;
  661. }
  662. sort_pacl(*pacl);
  663. sort_pacl(*dpacl);
  664. ret = 0;
  665. out_dstate:
  666. free_state(&default_acl_state);
  667. out_estate:
  668. free_state(&effective_acl_state);
  669. return ret;
  670. }
  671. static short
  672. ace2type(struct nfs4_ace *ace)
  673. {
  674. switch (ace->whotype) {
  675. case NFS4_ACL_WHO_NAMED:
  676. return (ace->flag & NFS4_ACE_IDENTIFIER_GROUP ?
  677. ACL_GROUP : ACL_USER);
  678. case NFS4_ACL_WHO_OWNER:
  679. return ACL_USER_OBJ;
  680. case NFS4_ACL_WHO_GROUP:
  681. return ACL_GROUP_OBJ;
  682. case NFS4_ACL_WHO_EVERYONE:
  683. return ACL_OTHER;
  684. }
  685. BUG();
  686. return -1;
  687. }
  688. EXPORT_SYMBOL(nfs4_acl_posix_to_nfsv4);
  689. EXPORT_SYMBOL(nfs4_acl_nfsv4_to_posix);
  690. struct nfs4_acl *
  691. nfs4_acl_new(int n)
  692. {
  693. struct nfs4_acl *acl;
  694. acl = kmalloc(sizeof(*acl) + n*sizeof(struct nfs4_ace), GFP_KERNEL);
  695. if (acl == NULL)
  696. return NULL;
  697. acl->naces = 0;
  698. return acl;
  699. }
  700. void
  701. nfs4_acl_add_ace(struct nfs4_acl *acl, u32 type, u32 flag, u32 access_mask,
  702. int whotype, uid_t who)
  703. {
  704. struct nfs4_ace *ace = acl->aces + acl->naces;
  705. ace->type = type;
  706. ace->flag = flag;
  707. ace->access_mask = access_mask;
  708. ace->whotype = whotype;
  709. ace->who = who;
  710. acl->naces++;
  711. }
  712. static struct {
  713. char *string;
  714. int stringlen;
  715. int type;
  716. } s2t_map[] = {
  717. {
  718. .string = "OWNER@",
  719. .stringlen = sizeof("OWNER@") - 1,
  720. .type = NFS4_ACL_WHO_OWNER,
  721. },
  722. {
  723. .string = "GROUP@",
  724. .stringlen = sizeof("GROUP@") - 1,
  725. .type = NFS4_ACL_WHO_GROUP,
  726. },
  727. {
  728. .string = "EVERYONE@",
  729. .stringlen = sizeof("EVERYONE@") - 1,
  730. .type = NFS4_ACL_WHO_EVERYONE,
  731. },
  732. };
  733. int
  734. nfs4_acl_get_whotype(char *p, u32 len)
  735. {
  736. int i;
  737. for (i = 0; i < ARRAY_SIZE(s2t_map); i++) {
  738. if (s2t_map[i].stringlen == len &&
  739. 0 == memcmp(s2t_map[i].string, p, len))
  740. return s2t_map[i].type;
  741. }
  742. return NFS4_ACL_WHO_NAMED;
  743. }
  744. int
  745. nfs4_acl_write_who(int who, char *p)
  746. {
  747. int i;
  748. for (i = 0; i < ARRAY_SIZE(s2t_map); i++) {
  749. if (s2t_map[i].type == who) {
  750. memcpy(p, s2t_map[i].string, s2t_map[i].stringlen);
  751. return s2t_map[i].stringlen;
  752. }
  753. }
  754. BUG();
  755. return -1;
  756. }
  757. EXPORT_SYMBOL(nfs4_acl_new);
  758. EXPORT_SYMBOL(nfs4_acl_add_ace);
  759. EXPORT_SYMBOL(nfs4_acl_get_whotype);
  760. EXPORT_SYMBOL(nfs4_acl_write_who);