Excise snprintf -> slprintf.
[kai/samba.git] / source3 / lib / sysacls.c
1 /* 
2    Unix SMB/Netbios implementation.
3    Version 2.2.
4    Samba system utilities for ACL support.
5    Copyright (C) Jeremy Allison 2000.
6    
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11    
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16    
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
22 #include "includes.h"
23
24 extern int DEBUGLEVEL;
25
26 /*
27  This file wraps all differing system ACL interfaces into a consistent
28  one based on the POSIX interface. It also returns the correct errors
29  for older UNIX systems that don't support ACLs.
30
31  The interfaces that each ACL implementation must support are as follows :
32
33  int sys_acl_get_entry( SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
34  int sys_acl_get_tag_type( SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p)
35  int sys_acl_get_permset( SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p
36  void *sys_acl_get_qualifier( SMB_ACL_ENTRY_T entry_d)
37  SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_ACL_TYPE_T type)
38  SMB_ACL_T sys_acl_get_fd(int fd)
39  int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset);
40  int sys_acl_add_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm);
41  char *sys_acl_to_text( SMB_ACL_T theacl, ssize_t *plen)
42  SMB_ACL_T sys_acl_init( int count)
43  int sys_acl_create_entry( SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry)
44  int sys_acl_set_tag_type( SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype)
45  int sys_acl_set_qualifier( SMB_ACL_ENTRY_T entry, void *qual)
46  int sys_acl_set_permset( SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset)
47  int sys_acl_valid( SMB_ACL_T theacl )
48  int sys_acl_set_file( char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
49  int sys_acl_set_fd( int fd, SMB_ACL_T theacl)
50
51  This next one is not POSIX complient - but we *have* to have it !
52  More POSIX braindamage.
53
54  int sys_acl_get_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
55
56  The generic POSIX free is the following call. We split this into
57  several different free functions as we may need to add tag info
58  to structures when emulating the POSIX interface.
59
60  int sys_acl_free( void *obj_p)
61
62  The calls we actually use are :
63
64  int sys_acl_free_text(char *text) - free acl_to_text
65  int sys_acl_free_acl(SMB_ACL_T posix_acl)
66
67 */
68
69 #if defined(HAVE_POSIX_ACLS)
70
71 /* Identity mapping - easy. */
72
73 int sys_acl_get_entry( SMB_ACL_T the_acl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
74 {
75         return acl_get_entry( the_acl, entry_id, entry_p);
76 }
77
78 int sys_acl_get_tag_type( SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p)
79 {
80         return acl_get_tag_type( entry_d, tag_type_p);
81 }
82
83 int sys_acl_get_permset( SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p)
84 {
85         return acl_get_permset( entry_d, permset_p);
86 }
87
88 void *sys_acl_get_qualifier( SMB_ACL_ENTRY_T entry_d)
89 {
90         return acl_get_qualifier( entry_d);
91 }
92
93 SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_ACL_TYPE_T type)
94 {
95         return acl_get_file( path_p, type);
96 }
97
98 SMB_ACL_T sys_acl_get_fd(int fd)
99 {
100         return acl_get_fd(fd);
101 }
102
103 int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset)
104 {
105         return acl_clear_perms(permset);
106 }
107
108 int sys_acl_add_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
109 {
110         return acl_add_perm(permset, perm);
111 }
112
113 int sys_acl_get_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
114 {
115         return acl_get_perm(permset, perm);
116 }
117
118 char *sys_acl_to_text( SMB_ACL_T the_acl, ssize_t *plen)
119 {
120         return acl_to_text( the_acl, plen);
121 }
122
123 SMB_ACL_T sys_acl_init( int count)
124 {
125         return acl_init(count);
126 }
127
128 int sys_acl_create_entry( SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry)
129 {
130         return acl_create_entry(pacl, pentry);
131 }
132
133 int sys_acl_set_tag_type( SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype)
134 {
135         return acl_set_tag_type(entry, tagtype);
136 }
137
138 int sys_acl_set_qualifier( SMB_ACL_ENTRY_T entry, void *qual)
139 {
140         return acl_set_qualifier(entry, qual);
141 }
142
143 int sys_acl_set_permset( SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset)
144 {
145         return acl_set_permset(entry, permset);
146 }
147
148 int sys_acl_valid( SMB_ACL_T theacl )
149 {
150         return acl_valid(theacl);
151 }
152
153 int sys_acl_set_file( char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
154 {
155         return acl_set_file(name, acltype, theacl);
156 }
157
158 int sys_acl_set_fd( int fd, SMB_ACL_T theacl)
159 {
160         return acl_set_fd(fd, theacl);
161 }
162
163 int sys_acl_free_text(char *text)
164 {
165         return acl_free(text);
166 }
167
168 int sys_acl_free_acl(SMB_ACL_T the_acl) 
169 {
170         return acl_free(the_acl);
171 }
172
173 #elif defined(HAVE_UNIXWARE_ACLS)
174
175 /*
176  * Donated by Michael Davidson <md@sco.COM> for UnixWare.
177  * As this is generic SVR4.x code, it may also work for Solaris !
178  */
179
180 #define INITIAL_ACL_SIZE        16
181 #ifndef SETACL
182 #define SETACL          ACL_SET
183 #endif
184
185 #ifndef GETACL
186 #define GETACL          ACL_GET
187 #endif
188
189 #ifndef GETACLCNT
190 #define GETACLCNT       ACL_CNT
191 #endif
192
193 #ifndef HAVE__FACL
194 /*
195  * until official facl() support shows up in UW 7.1.2
196  */
197  int facl(int fd, int cmd, int nentries, struct acl *aclbufp)
198 {
199         return syscall(188, fd, cmd, nentries, aclbufp);
200 }
201 #endif
202
203
204 int sys_acl_get_entry(SMB_ACL_T acl_d, int entry_id, SMB_ACL_ENTRY_T *entry_p)
205 {
206         if (entry_id != SMB_ACL_FIRST_ENTRY && entry_id != SMB_ACL_NEXT_ENTRY) {
207                 errno = EINVAL;
208                 return -1;
209         }
210
211         if (entry_p == NULL) {
212                 errno = EINVAL;
213                 return -1;
214         }
215
216         if (entry_id == SMB_ACL_FIRST_ENTRY) {
217                 acl_d->next = 0;
218         }
219
220         if (acl_d->next < 0) {
221                 errno = EINVAL;
222                 return -1;
223         }
224
225         if (acl_d->next >= acl_d->count) {
226                 return 0;
227         }
228
229         *entry_p = &acl_d->acl[acl_d->next++];
230
231         return 1;
232 }
233
234 int sys_acl_get_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *type_p)
235 {
236         *type_p = entry_d->a_type;
237
238         return 0;
239 }
240
241 int sys_acl_get_permset(SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p)
242 {
243         *permset_p = &entry_d->a_perm;
244
245         return 0;
246 }
247
248 void *sys_acl_get_qualifier(SMB_ACL_ENTRY_T entry_d)
249 {
250         if (entry_d->a_type != SMB_ACL_USER
251             && entry_d->a_type != SMB_ACL_GROUP) {
252                 errno = EINVAL;
253                 return NULL;
254         }
255
256         return &entry_d->a_id;
257 }
258
259 SMB_ACL_T sys_acl_get_file(const char *path_p, SMB_ACL_TYPE_T type)
260 {
261         SMB_ACL_T       acl_d;
262         int             count;          /* # of ACL entries allocated   */
263         int             naccess;        /* # of access ACL entries      */
264         int             ndefault;       /* # of default ACL entries     */
265
266         if (type != SMB_ACL_TYPE_ACCESS && type != SMB_ACL_TYPE_DEFAULT) {
267                 errno = EINVAL;
268                 return NULL;
269         }
270
271         count = INITIAL_ACL_SIZE;
272         if ((acl_d = sys_acl_init(count)) == NULL) {
273                 return NULL;
274         }
275
276         while ((count = acl(path_p, GETACL, count, &acl_d->acl[0])) < 0
277             && errno == ENOSPC) {
278
279                 if ((count = acl(path_p, GETACLCNT, 0, NULL)) < 0) {
280                         return NULL;
281                 }
282
283                 sys_acl_free_acl(acl_d);
284
285                 if ((acl_d = sys_acl_init(count)) == NULL) {
286                         return NULL;
287                 }
288         }
289
290         if (count < 0) {
291                 return NULL;
292         }
293
294         /*
295          * calculate the number of access and default ACL entries
296          *
297          * Note: we assume that the acl() system call returned a
298          * well formed ACL which is sorted so that all of the
299          * access ACL entries preceed any default ACL entries
300          */
301         for (naccess = 0; naccess < count; naccess++) {
302                 if (acl_d->acl[naccess].a_type & ACL_DEFAULT)
303                         break;
304         }
305         ndefault = count - naccess;
306         
307         /*
308          * if the caller wants the default ACL we have to copy
309          * the entries down to the start of the acl[] buffer
310          * and mask out the ACL_DEFAULT flag from the type field
311          */
312         if (type == SMB_ACL_TYPE_DEFAULT) {
313                 int     i, j;
314
315                 for (i = 0, j = naccess; i < ndefault; i++, j++) {
316                         acl_d->acl[i] = acl_d->acl[j];
317                         acl_d->acl[i].a_type &= ~ACL_DEFAULT;
318                 }
319
320                 acl_d->count = ndefault;
321         } else {
322                 acl_d->count = naccess;
323         }
324
325         return acl_d;
326 }
327
328 SMB_ACL_T sys_acl_get_fd(int fd)
329 {
330         SMB_ACL_T       acl_d;
331         int             count;          /* # of ACL entries allocated   */
332         int             naccess;        /* # of access ACL entries      */
333
334         count = INITIAL_ACL_SIZE;
335         if ((acl_d = sys_acl_init(count)) == NULL) {
336                 return NULL;
337         }
338
339         while ((count = facl(fd, GETACL, count, &acl_d->acl[0])) < 0
340             && errno == ENOSPC) {
341
342                 if ((count = facl(fd, GETACLCNT, 0, NULL)) < 0) {
343                         return NULL;
344                 }
345
346                 sys_acl_free_acl(acl_d);
347
348                 if ((acl_d = sys_acl_init(count)) == NULL) {
349                         return NULL;
350                 }
351         }
352
353         if (count < 0) {
354                 return NULL;
355         }
356
357         /*
358          * calculate the number of access ACL entries
359          */
360         for (naccess = 0; naccess < count; naccess++) {
361                 if (acl_d->acl[naccess].a_type & ACL_DEFAULT)
362                         break;
363         }
364         
365         acl_d->count = naccess;
366
367         return acl_d;
368 }
369
370 int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset_d)
371 {
372         *permset_d = 0;
373
374         return 0;
375 }
376
377 int sys_acl_add_perm(SMB_ACL_PERMSET_T permset_d, SMB_ACL_PERM_T perm)
378 {
379         if (perm != SMB_ACL_READ && perm != SMB_ACL_WRITE
380             && perm != SMB_ACL_EXECUTE) {
381                 errno = EINVAL;
382                 return -1;
383         }
384
385         if (permset_d == NULL) {
386                 errno = EINVAL;
387                 return -1;
388         }
389
390         *permset_d |= perm;
391
392         return 0;
393 }
394
395 int sys_acl_get_perm(SMB_ACL_PERMSET_T permset_d, SMB_ACL_PERM_T perm)
396 {
397         return *permset_d & perm;
398 }
399
400 char *sys_acl_to_text(SMB_ACL_T acl_d, ssize_t *len_p)
401 {
402         int     i;
403         int     len, maxlen;
404         char    *text;
405
406         /*
407          * use an initial estimate of 20 bytes per ACL entry
408          * when allocating memory for the text representation
409          * of the ACL
410          */
411         len     = 0;
412         maxlen  = 20 * acl_d->count;
413         if ((text = malloc(maxlen)) == NULL) {
414                 errno = ENOMEM;
415                 return NULL;
416         }
417
418         for (i = 0; i < acl_d->count; i++) {
419                 struct acl      *ap     = &acl_d->acl[i];
420                 struct passwd   *pw;
421                 struct group    *gr;
422                 char            tagbuf[12];
423                 char            idbuf[12];
424                 char            *tag;
425                 char            *id     = "";
426                 char            perms[4];
427                 int             nbytes;
428
429                 switch (ap->a_type) {
430                         /*
431                          * for debugging purposes it's probably more
432                          * useful to dump unknown tag types rather
433                          * than just returning an error
434                          */
435                         default:
436                                 slprintf(tagbuf, sizeof(tagbuf)-1, "0x%x",
437                                         ap->a_type);
438                                 tag = tagbuf;
439                                 slprintf(idbuf, sizeof(idbuf)-1, "%ld",
440                                         (long)ap->a_id);
441                                 id = idbuf;
442                                 break;
443
444                         case SMB_ACL_USER:
445                                 if ((pw = getpwuid(ap->a_id)) == NULL) {
446                                         slprintf(idbuf, sizeof(idbuf)-1, "%ld",
447                                                 (long)ap->a_id);
448                                         id = idbuf;
449                                 } else {
450                                         id = pw->pw_name;
451                                 }
452                         case SMB_ACL_USER_OBJ:
453                                 tag = "user";
454                                 break;
455
456                         case SMB_ACL_GROUP:
457                                 if ((gr = getgrgid(ap->a_id)) == NULL) {
458                                         slprintf(idbuf, sizeof(idbuf)-1, "%ld",
459                                                 (long)ap->a_id);
460                                         id = idbuf;
461                                 } else {
462                                         id = gr->gr_name;
463                                 }
464                         case SMB_ACL_GROUP_OBJ:
465                                 tag = "group";
466                                 break;
467
468                         case SMB_ACL_OTHER:
469                                 tag = "other";
470                                 break;
471
472                         case SMB_ACL_MASK:
473                                 tag = "mask";
474                                 break;
475
476                 }
477
478                 perms[0] = (ap->a_perm & S_IRUSR) ? 'r' : '-';
479                 perms[1] = (ap->a_perm & S_IWUSR) ? 'w' : '-';
480                 perms[2] = (ap->a_perm & S_IXUSR) ? 'x' : '-';
481                 perms[3] = '\0';
482
483                 /*          <tag>      :  <qualifier>   :  rwx \n  \0 */
484                 nbytes = strlen(tag) + 1 + strlen(id) + 1 + 3 + 1 + 1;
485
486                 if ((len + nbytes) > maxlen) {
487                         /*
488                          * allocate enough additional memory for this
489                          * entry and an estimate of another 20 bytes
490                          * for each entry still to be processed
491                          */
492                         maxlen += nbytes + 20 * (acl_d->count - i);
493
494                         if ((text = realloc(text, maxlen)) == NULL) {
495                                 errno = ENOMEM;
496                                 return NULL;
497                         }
498                 }
499
500                 slprintf(&text[len], nbytes-1, "%s:%s:%s\n", tag, id, perms);
501                 len += nbytes - 1;
502         }
503
504         if (len_p)
505                 *len_p = len;
506
507         return text;
508 }
509
510 SMB_ACL_T sys_acl_init(int count)
511 {
512         SMB_ACL_T       a;
513
514         if (count < 0) {
515                 errno = EINVAL;
516                 return NULL;
517         }
518
519         /*
520          * note that since the definition of the structure pointed
521          * to by the SMB_ACL_T includes the first element of the
522          * acl[] array, this actually allocates an ACL with room
523          * for (count+1) entries
524          */
525         if ((a = malloc(sizeof(*a) + count * sizeof(struct acl))) == NULL) {
526                 errno = ENOMEM;
527                 return NULL;
528         }
529
530         a->size = count + 1;
531         a->count = 0;
532         a->next = -1;
533
534         return a;
535 }
536
537
538 int sys_acl_create_entry(SMB_ACL_T *acl_p, SMB_ACL_ENTRY_T *entry_p)
539 {
540         SMB_ACL_T       acl_d;
541         SMB_ACL_ENTRY_T entry_d;
542
543         if (acl_p == NULL || entry_p == NULL || (acl_d = *acl_p) == NULL) {
544                 errno = EINVAL;
545                 return -1;
546         }
547
548         if (acl_d->count >= acl_d->size) {
549                 errno = ENOSPC;
550                 return -1;
551         }
552
553         entry_d         = &acl_d->acl[acl_d->count++];
554         entry_d->a_type = 0;
555         entry_d->a_id   = -1;
556         entry_d->a_perm = 0;
557         *entry_p        = entry_d;
558
559         return 0;
560 }
561
562 int sys_acl_set_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T tag_type)
563 {
564         switch (tag_type) {
565                 case SMB_ACL_USER:
566                 case SMB_ACL_USER_OBJ:
567                 case SMB_ACL_GROUP:
568                 case SMB_ACL_GROUP_OBJ:
569                 case SMB_ACL_OTHER:
570                 case SMB_ACL_MASK:
571                         entry_d->a_type = tag_type;
572                         break;
573                 default:
574                         errno = EINVAL;
575                         return -1;
576         }
577
578         return 0;
579 }
580
581 int sys_acl_set_qualifier(SMB_ACL_ENTRY_T entry_d, void *qual_p)
582 {
583         if (entry_d->a_type != SMB_ACL_GROUP
584             && entry_d->a_type != SMB_ACL_USER) {
585                 errno = EINVAL;
586                 return -1;
587         }
588
589         entry_d->a_id = *((id_t *)qual_p);
590
591         return 0;
592 }
593
594 int sys_acl_set_permset(SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T permset_d)
595 {
596         if (*permset_d & ~(SMB_ACL_READ|SMB_ACL_WRITE|SMB_ACL_EXECUTE)) {
597                 return EINVAL;
598         }
599
600         entry_d->a_perm = *permset_d;
601
602         return 0;
603 }
604
605 int sys_acl_valid(SMB_ACL_T acl_d)
606 {
607         if (aclsort(acl_d->count, 0, acl_d->acl) != 0) {
608                 errno = EINVAL;
609                 return -1;
610         }
611
612         return 0;
613 }
614
615 int sys_acl_set_file(char *name, SMB_ACL_TYPE_T type, SMB_ACL_T acl_d)
616 {
617         struct stat     s;
618         struct acl      *acl_p;
619         int             acl_count;
620         struct acl      *acl_buf        = NULL;
621         int             ret;
622
623         if (type != SMB_ACL_TYPE_ACCESS && type != SMB_ACL_TYPE_DEFAULT) {
624                 errno = EINVAL;
625                 return -1;
626         }
627
628         if (stat(name, &s) != 0) {
629                 return -1;
630         }
631
632         acl_p           = &acl_d->acl[0];
633         acl_count       = acl_d->count;
634
635         /*
636          * if it's a directory there is extra work to do
637          * since the acl() system call will replace both
638          * the access ACLs and the default ACLs (if any)
639          */
640         if (S_ISDIR(s.st_mode)) {
641                 SMB_ACL_T       acc_acl;
642                 SMB_ACL_T       def_acl;
643                 SMB_ACL_T       tmp_acl;
644                 int             i;
645
646                 if (type == SMB_ACL_TYPE_ACCESS) {
647                         acc_acl = acl_d;
648                         def_acl = 
649                         tmp_acl = sys_acl_get_file(name, SMB_ACL_TYPE_DEFAULT);
650
651                 } else {
652                         def_acl = acl_d;
653                         acc_acl = 
654                         tmp_acl = sys_acl_get_file(name, SMB_ACL_TYPE_ACCESS);
655                 }
656
657                 if (tmp_acl == NULL) {
658                         return -1;
659                 }
660
661                 /*
662                  * allocate a temporary buffer for the complete ACL
663                  */
664                 acl_count       = acc_acl->count + def_acl->count;
665                 acl_p           =
666                 acl_buf         = malloc(acl_count * sizeof(acl_buf[0]));
667
668                 if (acl_buf == NULL) {
669                         sys_acl_free_acl(tmp_acl);
670                         errno = ENOMEM;
671                         return -1;
672                 }
673
674                 /*
675                  * copy the access control and default entries into the buffer
676                  */
677                 memcpy(&acl_buf[0], &acc_acl->acl[0],
678                         acc_acl->count * sizeof(acl_buf[0]));
679
680                 memcpy(&acl_buf[acc_acl->count], &def_acl->acl[0],
681                         def_acl->count * sizeof(acl_buf[0]));
682
683                 /*
684                  * set the ACL_DEFAULT flag on the default entries
685                  */
686                 for (i = acc_acl->count; i < acl_count; i++) {
687                         acl_buf[i].a_type |= ACL_DEFAULT;
688                 }
689
690                 sys_acl_free_acl(tmp_acl);
691
692         } else if (type != SMB_ACL_TYPE_ACCESS) {
693                 errno = EINVAL;
694                 return -1;
695         }
696
697         if (aclsort(acl_count, 0, acl_p) != 0) {
698                 errno = EINVAL;
699                 ret = -1;
700         } else {
701                 ret = acl(name, SETACL, acl_count, acl_p);
702         }
703
704         if (acl_buf) {
705                 free(acl_buf);
706         }
707
708         return ret;
709 }
710
711 int sys_acl_set_fd(int fd, SMB_ACL_T acl_d)
712 {
713         if (aclsort(acl_d->count, 0, acl_d->acl) != 0) {
714                 errno = EINVAL;
715                 return -1;
716         }
717
718         return facl(fd, SETACL, acl_d->count, &acl_d->acl[0]);
719 }
720
721 int sys_acl_free_text(char *text)
722 {
723         free(text);
724         return 0;
725 }
726
727 int sys_acl_free_acl(SMB_ACL_T acl_d) 
728 {
729         free(acl_d);
730         return 0;
731 }
732 #elif defined(HAVE_SOLARIS_ACLS)
733
734 #elif defined(HAVE_IRIX_ACLS)
735
736 #else /* No ACLs. */
737
738 int sys_acl_get_entry( SMB_ACL_T the_acl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
739 {
740         return -1;
741 }
742
743 int sys_acl_get_tag_type( SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p)
744 {
745         return -1;
746 }
747
748 int sys_acl_get_permset( SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p)
749 {
750         return -1;
751 }
752
753 void *sys_acl_get_qualifier( SMB_ACL_ENTRY_T entry_d)
754 {
755         return NULL;
756 }
757
758 SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_ACL_TYPE_T type)
759 {
760         return (SMB_ACL_T)NULL;
761 }
762
763 SMB_ACL_T sys_acl_get_fd(int fd)
764 {
765         return (SMB_ACL_T)NULL;
766 }
767
768 int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset)
769 {
770         return -1;
771 }
772
773 int sys_acl_add_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
774 {
775         return -1;
776 }
777
778 int sys_acl_get_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
779 {
780         return (permset & perm) ? 1 : 0;
781 }
782
783 char *sys_acl_to_text( SMB_ACL_T the_acl, ssize_t *plen)
784 {
785         return NULL;
786 }
787
788 int sys_acl_free_text(char *text)
789 {
790         return -1;
791 }
792
793 SMB_ACL_T sys_acl_init( int count)
794 {
795         return NULL;
796 }
797
798 int sys_acl_create_entry( SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry)
799 {
800         return -1;
801 }
802
803 int sys_acl_set_tag_type( SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype)
804 {
805         return -1;
806 }
807
808 int sys_acl_set_qualifier( SMB_ACL_ENTRY_T entry, void *qual)
809 {
810         return -1;
811 }
812
813 int sys_acl_set_permset( SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset)
814 {
815         return -1;
816 }
817
818 int sys_acl_valid( SMB_ACL_T theacl )
819 {
820         return -1;
821 }
822
823 int sys_acl_set_file( char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
824 {
825         return -1;
826 }
827
828 int sys_acl_set_fd( int fd, SMB_ACL_T theacl)
829 {
830         return -1;
831 }
832
833 int sys_acl_free_acl(SMB_ACL_T the_acl) 
834 {
835         return -1;
836 }
837 #endif /* No ACLs. */