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