source: vendor/3.6.9/source3/modules/vfs_tru64acl.c

Last change on this file was 740, checked in by Silvan Scherrer, 13 years ago

Samba Server: update vendor to 3.6.0
File size: 13.5 KB
Line 
1/*
2 Unix SMB/Netbios implementation.
3 VFS module to get and set Tru64 acls
4 Copyright (C) Michael Adam 2006,2008
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
18*/
19
20#include "includes.h"
21#include "system/filesys.h"
22#include "smbd/smbd.h"
23#include "modules/vfs_tru64acl.h"
24
25/* prototypes for private functions first - for clarity */
26
27static struct smb_acl_t *tru64_acl_to_smb_acl(const struct acl *tru64_acl);
28static bool tru64_ace_to_smb_ace(acl_entry_t tru64_ace,
29 struct smb_acl_entry *smb_ace);
30static acl_t smb_acl_to_tru64_acl(const SMB_ACL_T smb_acl);
31static acl_tag_t smb_tag_to_tru64(SMB_ACL_TAG_T smb_tag);
32static SMB_ACL_TAG_T tru64_tag_to_smb(acl_tag_t tru64_tag);
33static acl_perm_t smb_permset_to_tru64(SMB_ACL_PERM_T smb_permset);
34static SMB_ACL_PERM_T tru64_permset_to_smb(const acl_perm_t tru64_permset);
35
36
37/* public functions - the api */
38
39SMB_ACL_T tru64acl_sys_acl_get_file(vfs_handle_struct *handle,
40 const char *path_p,
41 SMB_ACL_TYPE_T type)
42{
43 struct smb_acl_t *result;
44 acl_type_t the_acl_type;
45 acl_t tru64_acl;
46
47 DEBUG(10, ("Hi! This is tru64acl_sys_acl_get_file.\n"));
48
49 switch(type) {
50 case SMB_ACL_TYPE_ACCESS:
51 the_acl_type = ACL_TYPE_ACCESS;
52 break;
53 case SMB_ACL_TYPE_DEFAULT:
54 the_acl_type = ACL_TYPE_DEFAULT;
55 break;
56 default:
57 errno = EINVAL;
58 return NULL;
59 }
60
61 tru64_acl = acl_get_file((char *)path_p, the_acl_type);
62
63 if (tru64_acl == NULL) {
64 return NULL;
65 }
66
67 result = tru64_acl_to_smb_acl(tru64_acl);
68 acl_free(tru64_acl);
69 return result;
70}
71
72SMB_ACL_T tru64acl_sys_acl_get_fd(vfs_handle_struct *handle,
73 files_struct *fsp)
74{
75 struct smb_acl_t *result;
76 acl_t tru64_acl = acl_get_fd(fsp->fh->fd, ACL_TYPE_ACCESS);
77
78 if (tru64_acl == NULL) {
79 return NULL;
80 }
81
82 result = tru64_acl_to_smb_acl(tru64_acl);
83 acl_free(tru64_acl);
84 return result;
85}
86
87int tru64acl_sys_acl_set_file(vfs_handle_struct *handle,
88 const char *name,
89 SMB_ACL_TYPE_T type,
90 SMB_ACL_T theacl)
91{
92 int res;
93 acl_type_t the_acl_type;
94 acl_t tru64_acl;
95
96 DEBUG(10, ("tru64acl_sys_acl_set_file called with name %s, type %d\n",
97 name, type));
98
99 switch(type) {
100 case SMB_ACL_TYPE_ACCESS:
101 DEBUGADD(10, ("got acl type ACL_TYPE_ACCESS\n"));
102 the_acl_type = ACL_TYPE_ACCESS;
103 break;
104 case SMB_ACL_TYPE_DEFAULT:
105 DEBUGADD(10, ("got acl type ACL_TYPE_DEFAULT\n"));
106 the_acl_type = ACL_TYPE_DEFAULT;
107 break;
108 default:
109 DEBUGADD(10, ("invalid acl type\n"));
110 errno = EINVAL;
111 goto fail;
112 }
113
114 tru64_acl = smb_acl_to_tru64_acl(theacl);
115 if (tru64_acl == NULL) {
116 DEBUG(10, ("smb_acl_to_tru64_acl failed!\n"));
117 goto fail;
118 }
119 DEBUG(10, ("got tru64 acl...\n"));
120 res = acl_set_file((char *)name, the_acl_type, tru64_acl);
121 acl_free(tru64_acl);
122 if (res != 0) {
123 DEBUG(10, ("acl_set_file failed: %s\n", strerror(errno)));
124 goto fail;
125 }
126 return res;
127fail:
128 DEBUG(1, ("tru64acl_sys_acl_set_file failed!\n"));
129 return -1;
130}
131
132int tru64acl_sys_acl_set_fd(vfs_handle_struct *handle,
133 files_struct *fsp,
134 SMB_ACL_T theacl)
135{
136 int res;
137 acl_t tru64_acl = smb_acl_to_tru64_acl(theacl);
138 if (tru64_acl == NULL) {
139 return -1;
140 }
141 res = acl_set_fd(fsp->fh->fd, ACL_TYPE_ACCESS, tru64_acl);
142 acl_free(tru64_acl);
143 return res;
144
145}
146
147int tru64acl_sys_acl_delete_def_file(vfs_handle_struct *handle,
148 const char *path)
149{
150 return acl_delete_def_file((char *)path);
151}
152
153
154/* private functions */
155
156static struct smb_acl_t *tru64_acl_to_smb_acl(const struct acl *tru64_acl)
157{
158 struct smb_acl_t *result;
159 acl_entry_t entry;
160
161 DEBUG(10, ("Hi! This is tru64_acl_to_smb_acl.\n"));
162
163 if ((result = SMB_MALLOC_P(struct smb_acl_t)) == NULL) {
164 DEBUG(0, ("SMB_MALLOC_P failed in tru64_acl_to_smb_acl\n"));
165 errno = ENOMEM;
166 goto fail;
167 }
168 ZERO_STRUCTP(result);
169 if (acl_first_entry((struct acl *)tru64_acl) != 0) {
170 DEBUG(10, ("acl_first_entry failed: %s\n", strerror(errno)));
171 goto fail;
172 }
173 while ((entry = acl_get_entry((struct acl *)tru64_acl)) != NULL) {
174 result = SMB_REALLOC(result, sizeof(struct smb_acl_t) +
175 (sizeof(struct smb_acl_entry) *
176 (result->count + 1)));
177 if (result == NULL) {
178 DEBUG(0, ("SMB_REALLOC failed in tru64_acl_to_smb_acl\n"));
179 errno = ENOMEM;
180 goto fail;
181 }
182 /* XYZ */
183 if (!tru64_ace_to_smb_ace(entry, &result->acl[result->count])) {
184 SAFE_FREE(result);
185 goto fail;
186 }
187 result->count += 1;
188 }
189 return result;
190
191fail:
192 if (result != NULL) {
193 SAFE_FREE(result);
194 }
195 DEBUG(1, ("tru64_acl_to_smb_acl failed!\n"));
196 return NULL;
197}
198
199static bool tru64_ace_to_smb_ace(acl_entry_t tru64_ace,
200 struct smb_acl_entry *smb_ace)
201{
202 acl_tag_t tru64_tag;
203 acl_permset_t permset;
204 SMB_ACL_TAG_T smb_tag_type;
205 SMB_ACL_PERM_T smb_permset;
206 void *qualifier;
207
208 if (acl_get_tag_type(tru64_ace, &tru64_tag) != 0) {
209 DEBUG(0, ("acl_get_tag_type failed: %s\n", strerror(errno)));
210 return False;
211 }
212
213 /* On could set the tag type directly to save a function call,
214 * but I like this better... */
215 smb_tag_type = tru64_tag_to_smb(tru64_tag);
216 if (smb_tag_type == 0) {
217 DEBUG(3, ("invalid tag type given: %d\n", tru64_tag));
218 return False;
219 }
220 if (sys_acl_set_tag_type(smb_ace, smb_tag_type) != 0) {
221 DEBUG(3, ("sys_acl_set_tag_type failed: %s\n",
222 strerror(errno)));
223 return False;
224 }
225 qualifier = acl_get_qualifier(tru64_ace);
226 if (qualifier != NULL) {
227 if (sys_acl_set_qualifier(smb_ace, qualifier) != 0) {
228 DEBUG(3, ("sys_acl_set_qualifier failed\n"));
229 return False;
230 }
231 }
232 if (acl_get_permset(tru64_ace, &permset) != 0) {
233 DEBUG(3, ("acl_get_permset failed: %s\n", strerror(errno)));
234 return False;
235 }
236 smb_permset = tru64_permset_to_smb(*permset);
237 if (sys_acl_set_permset(smb_ace, &smb_permset) != 0) {
238 DEBUG(3, ("sys_acl_set_permset failed: %s\n", strerror(errno)));
239 return False;
240 }
241 return True;
242}
243
244static acl_t smb_acl_to_tru64_acl(const SMB_ACL_T smb_acl)
245{
246 acl_t result;
247 acl_entry_t tru64_entry;
248 int i;
249 char *acl_text;
250 ssize_t acl_text_len;
251
252 /* The tru64 acl_init function takes a size_t value
253 * instead of a count of entries (as with posix).
254 * the size parameter "Specifies the size of the working
255 * storage in bytes" (according to the man page).
256 * But it is unclear to me, how this size is to be
257 * calculated.
258 *
259 * It should not matter, since acl_create_entry enlarges
260 * the working storage at need. ... */
261
262 DEBUG(10, ("Hi! This is smb_acl_to_tru64_acl.\n"));
263
264 result = acl_init(1);
265
266 if (result == NULL) {
267 DEBUG(3, ("acl_init failed!\n"));
268 goto fail;
269 }
270
271 DEBUGADD(10, ("parsing acl entries...\n"));
272 for (i = 0; i < smb_acl->count; i++) {
273 /* XYZ - maybe eliminate this direct access? */
274 const struct smb_acl_entry *smb_entry = &smb_acl->acl[i];
275 acl_tag_t tru64_tag;
276 acl_perm_t tru64_permset;
277
278 tru64_tag = smb_tag_to_tru64(smb_entry->a_type);
279 if (tru64_tag == -1) {
280 DEBUG(3, ("smb_tag_to_tru64 failed!\n"));
281 goto fail;
282 }
283
284 if (tru64_tag == ACL_MASK) {
285 DEBUGADD(10, (" - acl type ACL_MASK: not implemented on Tru64 ==> skipping\n"));
286 continue;
287 }
288
289 tru64_entry = acl_create_entry(&result);
290 if (tru64_entry == NULL) {
291 DEBUG(3, ("acl_create_entry failed: %s\n",
292 strerror(errno)));
293 goto fail;
294 }
295
296 if (acl_set_tag_type(tru64_entry, tru64_tag) != 0) {
297 DEBUG(3, ("acl_set_tag_type(%d) failed: %s\n",
298 strerror(errno)));
299 goto fail;
300 }
301
302 switch (smb_entry->a_type) {
303 case SMB_ACL_USER:
304 if (acl_set_qualifier(tru64_entry,
305 (int *)&smb_entry->uid) != 0)
306 {
307 DEBUG(3, ("acl_set_qualifier failed: %s\n",
308 strerror(errno)));
309 goto fail;
310 }
311 DEBUGADD(10, (" - setting uid to %d\n", smb_entry->uid));
312 break;
313 case SMB_ACL_GROUP:
314 if (acl_set_qualifier(tru64_entry,
315 (int *)&smb_entry->gid) != 0)
316 {
317 DEBUG(3, ("acl_set_qualifier failed: %s\n",
318 strerror(errno)));
319 goto fail;
320 }
321 DEBUGADD(10, (" - setting gid to %d\n", smb_entry->gid));
322 break;
323 default:
324 break;
325 }
326
327 tru64_permset = smb_permset_to_tru64(smb_entry->a_perm);
328 if (tru64_permset == -1) {
329 DEBUG(3, ("smb_permset_to_tru64 failed!\n"));
330 goto fail;
331 }
332 DEBUGADD(10, (" - setting perms to %0d\n", tru64_permset));
333 if (acl_set_permset(tru64_entry, &tru64_permset) != 0)
334 {
335 DEBUG(3, ("acl_set_permset failed: %s\n", strerror(errno)));
336 goto fail;
337 }
338 } /* for */
339 DEBUGADD(10, ("done parsing acl entries\n"));
340
341 tru64_entry = NULL;
342 if (acl_valid(result, &tru64_entry) != 0) {
343 DEBUG(1, ("smb_acl_to_tru64_acl: ACL is invalid (%s)\n",
344 strerror(errno)));
345 if (tru64_entry != NULL) {
346 DEBUGADD(1, ("the acl contains duplicate entries\n"));
347 }
348 goto fail;
349 }
350 DEBUGADD(10, ("acl is valid\n"));
351
352 acl_text = acl_to_text(result, &acl_text_len);
353 if (acl_text == NULL) {
354 DEBUG(3, ("acl_to_text failed: %s\n", strerror(errno)));
355 goto fail;
356 }
357 DEBUG(1, ("acl_text: %s\n", acl_text));
358 free(acl_text);
359
360 return result;
361
362fail:
363 if (result != NULL) {
364 acl_free(result);
365 }
366 DEBUG(1, ("smb_acl_to_tru64_acl failed!\n"));
367 return NULL;
368}
369
370static acl_tag_t smb_tag_to_tru64(SMB_ACL_TAG_T smb_tag)
371{
372 acl_tag_t result;
373 switch (smb_tag) {
374 case SMB_ACL_USER:
375 result = ACL_USER;
376 DEBUGADD(10, ("got acl type ACL_USER\n"));
377 break;
378 case SMB_ACL_USER_OBJ:
379 result = ACL_USER_OBJ;
380 DEBUGADD(10, ("got acl type ACL_USER_OBJ\n"));
381 break;
382 case SMB_ACL_GROUP:
383 result = ACL_GROUP;
384 DEBUGADD(10, ("got acl type ACL_GROUP\n"));
385 break;
386 case SMB_ACL_GROUP_OBJ:
387 result = ACL_GROUP_OBJ;
388 DEBUGADD(10, ("got acl type ACL_GROUP_OBJ\n"));
389 break;
390 case SMB_ACL_OTHER:
391 result = ACL_OTHER;
392 DEBUGADD(10, ("got acl type ACL_OTHER\n"));
393 break;
394 case SMB_ACL_MASK:
395 result = ACL_MASK;
396 DEBUGADD(10, ("got acl type ACL_MASK\n"));
397 break;
398 default:
399 DEBUG(1, ("Unknown tag type %d\n", smb_tag));
400 result = -1;
401 }
402 return result;
403}
404
405
406static SMB_ACL_TAG_T tru64_tag_to_smb(acl_tag_t tru64_tag)
407{
408 SMB_ACL_TAG_T smb_tag_type;
409 switch(tru64_tag) {
410 case ACL_USER:
411 smb_tag_type = SMB_ACL_USER;
412 DEBUGADD(10, ("got smb acl tag type SMB_ACL_USER\n"));
413 break;
414 case ACL_USER_OBJ:
415 smb_tag_type = SMB_ACL_USER_OBJ;
416 DEBUGADD(10, ("got smb acl tag type SMB_ACL_USER_OBJ\n"));
417 break;
418 case ACL_GROUP:
419 smb_tag_type = SMB_ACL_GROUP;
420 DEBUGADD(10, ("got smb acl tag type SMB_ACL_GROUP\n"));
421 break;
422 case ACL_GROUP_OBJ:
423 smb_tag_type = SMB_ACL_GROUP_OBJ;
424 DEBUGADD(10, ("got smb acl tag type SMB_ACL_GROUP_OBJ\n"));
425 break;
426 case ACL_OTHER:
427 smb_tag_type = SMB_ACL_OTHER;
428 DEBUGADD(10, ("got smb acl tag type SMB_ACL_OTHER\n"));
429 break;
430 case ACL_MASK:
431 smb_tag_type = SMB_ACL_MASK;
432 DEBUGADD(10, ("got smb acl tag type SMB_ACL_MASK\n"));
433 break;
434 default:
435 DEBUG(0, ("Unknown tag type %d\n", (unsigned int)tru64_tag));
436 smb_tag_type = 0;
437 }
438 return smb_tag_type;
439}
440
441static acl_perm_t smb_permset_to_tru64(SMB_ACL_PERM_T smb_permset)
442{
443 /* originally, I thought that acl_clear_perm was the
444 * proper way to reset the permset to 0. but without
445 * initializing it to 0, acl_clear_perm fails.
446 * so probably, acl_clear_perm is not necessary here... ?! */
447 acl_perm_t tru64_permset = 0;
448 if (acl_clear_perm(&tru64_permset) != 0) {
449 DEBUG(5, ("acl_clear_perm failed: %s\n", strerror(errno)));
450 return -1;
451 }
452 /* according to original lib/sysacls.c, acl_add_perm is
453 * broken on tru64 ... */
454 tru64_permset |= ((smb_permset & SMB_ACL_READ) ? ACL_READ : 0);
455 tru64_permset |= ((smb_permset & SMB_ACL_WRITE) ? ACL_WRITE : 0);
456 tru64_permset |= ((smb_permset & SMB_ACL_EXECUTE) ? ACL_EXECUTE : 0);
457 return tru64_permset;
458}
459
460static SMB_ACL_PERM_T tru64_permset_to_smb(const acl_perm_t tru64_permset)
461{
462 SMB_ACL_PERM_T smb_permset = 0;
463 smb_permset |= ((tru64_permset & ACL_READ) ? SMB_ACL_READ : 0);
464 smb_permset |= ((tru64_permset & ACL_WRITE) ? SMB_ACL_WRITE : 0);
465 smb_permset |= ((tru64_permset & ACL_EXECUTE) ? SMB_ACL_EXECUTE : 0);
466 return smb_permset;
467}
468
469
470/* VFS operations structure */
471
472static struct vfs_fn_pointers tru64acl_fns = {
473 .sys_acl_get_file = tru64acl_sys_acl_get_file,
474 .sys_acl_get_fd = tru64acl_sys_acl_get_fd,
475 .sys_acl_set_file = tru64acl_sys_acl_set_file,
476 .sys_acl_set_fd = tru64acl_sys_acl_set_fd,
477 .sys_acl_delete_def_file = tru64acl_sys_acl_delete_def_file,
478};
479
480NTSTATUS vfs_tru64acl_init(void);
481NTSTATUS vfs_tru64acl_init(void)
482{
483 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "tru64acl",
484 &tru64acl_fns);
485}
486
487/* ENTE */
Note: See TracBrowser for help on using the repository browser.