LCOV - code coverage report
Current view: top level - src/client - acl.c (source / functions) Hit Total Coverage
Test: burp-coverage-clean.info Lines: 0 79 0.0 %
Date: 2016-01-03 Functions: 0 7 0.0 %

          Line data    Source code
       1             : #include "../burp.h"
       2             : #include "../alloc.h"
       3             : #include "../cmd.h"
       4             : #include "../log.h"
       5             : #include "../prepend.h"
       6             : #include "../sbuf.h"
       7             : #include "acl.h"
       8             : #include "extrameta.h"
       9             : 
      10             : #ifdef HAVE_ACL
      11             : #if defined(HAVE_LINUX_OS) || \
      12             :     defined(HAVE_FREEBSD_OS) || \
      13             :     defined(HAVE_NETBSD_OS)
      14             : #include "sys/acl.h"
      15             : 
      16             : /* Linux can do shorter ACLs */
      17             : #if defined(HAVE_LINUX_OS)
      18             : #include <acl/libacl.h>
      19             : #define acl_to_text(acl,len)        (acl_to_any_text((acl), NULL, ',', TEXT_ABBREVIATE|TEXT_NUMERIC_IDS))
      20             : #endif
      21             : 
      22             : // section of acl_is_trivial copied from bacula 
      23           0 : static int acl_is_trivial(acl_t acl)
      24             : {
      25             : #if defined(HAVE_LINUX_OS) \
      26             :  || defined(HAVE_FREEBSD_OS) \
      27             :  || defined(HAVE_NETBSD_OS)
      28             :         /*
      29             :          * acl is trivial if it has only the following entries:
      30             :          * "user::",
      31             :          * "group::",
      32             :          * "other::"
      33             :          */
      34             :         acl_entry_t ace;
      35             :         acl_tag_t tag;
      36             :         int entry_available;
      37             : 
      38           0 :         entry_available = acl_get_entry(acl, ACL_FIRST_ENTRY, &ace);
      39           0 :         while(entry_available==1)
      40             :         {
      41             :                 /*
      42             :                  * Get the tag type of this acl entry.
      43             :                  * If we fail to get the tagtype we call the acl non-trivial.
      44             :                  */
      45           0 :                 if (acl_get_tag_type(ace, &tag) < 0)
      46             :                         return true;
      47             :                 /*
      48             :                  * Anything other the ACL_USER_OBJ, ACL_GROUP_OBJ
      49             :                  * or ACL_OTHER breaks the spell.
      50             :                  */
      51           0 :                 if(tag!=ACL_USER_OBJ
      52           0 :                   && tag!=ACL_GROUP_OBJ
      53           0 :                   && tag!=ACL_OTHER)
      54             :                         return 0;
      55           0 :                 entry_available=acl_get_entry(acl, ACL_NEXT_ENTRY, &ace);
      56             :         }
      57             : #endif
      58             :         return 1;
      59             : }
      60             : 
      61           0 : static acl_t acl_contains_something(const char *path, int acl_type)
      62             : {
      63           0 :         acl_t acl=NULL;
      64           0 :         if(!(acl=acl_get_file(path, acl_type))) return NULL;
      65           0 :         if(!acl_is_trivial(acl)) return acl;
      66           0 :         acl_free(acl);
      67           0 :         return NULL;
      68             : }
      69             : 
      70           0 : int has_acl(const char *path, enum cmd cmd)
      71             : {
      72           0 :         acl_t acl=NULL;
      73           0 :         if(!(acl=acl_contains_something(path, ACL_TYPE_ACCESS))
      74           0 :           || (cmd==CMD_DIRECTORY
      75           0 :             && !(acl=acl_contains_something(path, ACL_TYPE_DEFAULT))))
      76             :                 return 0;
      77           0 :         acl_free(acl);
      78           0 :         return 1;
      79             : }
      80             : 
      81           0 : static int get_acl_string(struct asfd *asfd, acl_t acl, char **acltext,
      82             :         size_t *alen, const char *path, char type, struct cntr *cntr)
      83             : {
      84           0 :         int ret=0;
      85           0 :         char pre[10]="";
      86           0 :         char *tmp=NULL;
      87           0 :         ssize_t tlen=0;
      88           0 :         char *ourtext=NULL;
      89           0 :         ssize_t maxlen=0xFFFFFFFF/2;
      90             : 
      91           0 :         if(!(tmp=acl_to_text(acl, NULL)))
      92             :         {
      93           0 :                 logw(asfd, cntr, "could not get ACL text of '%s'\n", path);
      94           0 :                 goto end; // carry on
      95             :         }
      96             : 
      97           0 :         tlen=strlen(tmp);
      98             : 
      99           0 :         if(tlen>maxlen)
     100             :         {
     101           0 :                 logw(asfd, cntr, "ACL of '%s' too long: %d\n", path, tlen);
     102           0 :                 goto end; // carry on
     103             :         }
     104             : 
     105           0 :         snprintf(pre, sizeof(pre), "%c%08X", type, (unsigned int)tlen);
     106           0 :         if(!(ourtext=prepend(pre, tmp))
     107           0 :           || !(*acltext=prepend_len(*acltext,
     108           0 :                 *alen, ourtext, tlen+9, "", 0, alen)))
     109           0 :                         ret=-1;
     110             : end:
     111           0 :         free_w(&tmp);
     112           0 :         free_w(&ourtext);
     113           0 :         return ret;
     114             : }
     115             : 
     116           0 : int get_acl(struct asfd *asfd, struct sbuf *sb,
     117             :         char **acltext, size_t *alen, struct cntr *cntr)
     118             : {
     119           0 :         acl_t acl=NULL;
     120           0 :         const char *path=sb->path.buf;
     121             : 
     122           0 :         if((acl=acl_contains_something(path, ACL_TYPE_ACCESS)))
     123             :         {
     124           0 :                 if(get_acl_string(asfd, acl,
     125           0 :                         acltext, alen, path, META_ACCESS_ACL, cntr))
     126             :                 {
     127           0 :                         acl_free(acl);
     128           0 :                         return -1;
     129             :                 }
     130           0 :                 acl_free(acl);
     131             :         }
     132             : 
     133           0 :         if(S_ISDIR(sb->statp.st_mode))
     134             :         {
     135           0 :                 if((acl=acl_contains_something(path, ACL_TYPE_DEFAULT)))
     136             :                 {
     137           0 :                         if(get_acl_string(asfd, acl,
     138           0 :                                 acltext, alen, path, META_DEFAULT_ACL, cntr))
     139             :                         {
     140           0 :                                 acl_free(acl);
     141           0 :                                 return -1;
     142             :                         }
     143           0 :                         acl_free(acl);
     144             :                 }
     145             :         }
     146             :         return 0;
     147             : }
     148             : 
     149           0 : static int do_set_acl(struct asfd *asfd, const char *path,
     150             :         const char *acltext, size_t alen,
     151             :         int acltype, struct cntr *cntr)
     152             : {
     153             :         acl_t acl;
     154           0 :         int ret=-1;
     155           0 :         if(!(acl=acl_from_text(acltext)))
     156             :         {
     157             :                 logp("acl_from_text error on %s (%s): %s\n",
     158           0 :                         path, acltext, strerror(errno));
     159             :                 logw(asfd, cntr, "acl_from_text error on %s (%s): %s\n",
     160           0 :                         path, acltext, strerror(errno));
     161             :                 goto end;
     162             :         }
     163             : //#ifndef HAVE_FREEBSD_OS // Bacula says that acl_valid fails on valid input
     164             :                         // on freebsd. It works OK for me on FreeBSD 8.2.
     165           0 :         if(acl_valid(acl))
     166             :         {
     167           0 :                 logp("acl_valid error on %s: %s", path, strerror(errno));
     168             :                 logw(asfd, cntr, "acl_valid error on %s: %s\n",
     169           0 :                         path, strerror(errno));
     170             :                 goto end;
     171             :         }
     172             : //#endif
     173           0 :         if(acl_set_file(path, acltype, acl))
     174             :         {
     175           0 :                 logp("acl set error on %s: %s", path, strerror(errno));
     176             :                 logw(asfd, cntr, "acl set error on %s: %s\n",
     177           0 :                         path, strerror(errno));
     178             :                 goto end;
     179             :         }
     180             :         ret=0;
     181             : end:
     182           0 :         if(acl) acl_free(acl);
     183           0 :         return ret; 
     184             : }
     185             : 
     186           0 : int set_acl(struct asfd *asfd, const char *path, struct sbuf *sb,
     187             :         const char *acltext, size_t alen, char metacmd, struct cntr *cntr)
     188             : {
     189           0 :         switch(metacmd)
     190             :         {
     191             :                 case META_ACCESS_ACL:
     192             :                         return do_set_acl(asfd, path,
     193           0 :                                 acltext, alen, ACL_TYPE_ACCESS, cntr);
     194             :                 case META_DEFAULT_ACL:
     195             :                         return do_set_acl(asfd, path,
     196           0 :                                 acltext, alen, ACL_TYPE_DEFAULT, cntr);
     197             :                 default:
     198           0 :                         logp("unknown acl type: %c\n", metacmd);
     199           0 :                         logw(asfd, cntr, "unknown acl type: %c\n", metacmd);
     200             :                         break;
     201             :         }
     202           0 :         return -1;
     203             : }
     204             : 
     205             : #endif // LINUX | BSD
     206             : #endif // HAVE_ACL

Generated by: LCOV version 1.10