Return to virtio-9p-posix-acl.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / hw

Annotation of qemu/hw/virtio-9p-posix-acl.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Virtio 9p system.posix* xattr callback
                      3:  *
                      4:  * Copyright IBM, Corp. 2010
                      5:  *
                      6:  * Authors:
                      7:  * Aneesh Kumar K.V <[email protected]>
                      8:  *
                      9:  * This work is licensed under the terms of the GNU GPL, version 2.  See
                     10:  * the COPYING file in the top-level directory.
                     11:  *
                     12:  */
                     13: 
                     14: #include <sys/types.h>
                     15: #include <attr/xattr.h>
                     16: #include "virtio.h"
                     17: #include "virtio-9p.h"
                     18: #include "file-op-9p.h"
                     19: #include "virtio-9p-xattr.h"
                     20: 
                     21: #define MAP_ACL_ACCESS "user.virtfs.system.posix_acl_access"
                     22: #define MAP_ACL_DEFAULT "user.virtfs.system.posix_acl_default"
                     23: #define ACL_ACCESS "system.posix_acl_access"
                     24: #define ACL_DEFAULT "system.posix_acl_default"
                     25: 
                     26: static ssize_t mp_pacl_getxattr(FsContext *ctx, const char *path,
                     27:                                 const char *name, void *value, size_t size)
                     28: {
                     29:     return lgetxattr(rpath(ctx, path), MAP_ACL_ACCESS, value, size);
                     30: }
                     31: 
                     32: static ssize_t mp_pacl_listxattr(FsContext *ctx, const char *path,
                     33:                                  char *name, void *value, size_t osize)
                     34: {
                     35:     ssize_t len = sizeof(ACL_ACCESS);
                     36: 
                     37:     if (!value) {
                     38:         return len;
                     39:     }
                     40: 
                     41:     if (osize < len) {
                     42:         errno = ERANGE;
                     43:         return -1;
                     44:     }
                     45: 
                     46:     strncpy(value, ACL_ACCESS, len);
                     47:     return 0;
                     48: }
                     49: 
                     50: static int mp_pacl_setxattr(FsContext *ctx, const char *path, const char *name,
                     51:                             void *value, size_t size, int flags)
                     52: {
                     53:     return lsetxattr(rpath(ctx, path), MAP_ACL_ACCESS, value, size, flags);
                     54: }
                     55: 
                     56: static int mp_pacl_removexattr(FsContext *ctx,
                     57:                                const char *path, const char *name)
                     58: {
                     59:     int ret;
                     60:     ret  = lremovexattr(rpath(ctx, path), MAP_ACL_ACCESS);
                     61:     if (ret == -1 && errno == ENODATA) {
                     62:         /*
                     63:          * We don't get ENODATA error when trying to remote a
                     64:          * posix acl that is not present. So don't throw the error
                     65:          * even in case of mapped security model
                     66:          */
                     67:         errno = 0;
                     68:         ret = 0;
                     69:     }
                     70:     return ret;
                     71: }
                     72: 
                     73: static ssize_t mp_dacl_getxattr(FsContext *ctx, const char *path,
                     74:                                 const char *name, void *value, size_t size)
                     75: {
                     76:     return lgetxattr(rpath(ctx, path), MAP_ACL_DEFAULT, value, size);
                     77: }
                     78: 
                     79: static ssize_t mp_dacl_listxattr(FsContext *ctx, const char *path,
                     80:                                  char *name, void *value, size_t osize)
                     81: {
                     82:     ssize_t len = sizeof(ACL_DEFAULT);
                     83: 
                     84:     if (!value) {
                     85:         return len;
                     86:     }
                     87: 
                     88:     if (osize < len) {
                     89:         errno = ERANGE;
                     90:         return -1;
                     91:     }
                     92: 
                     93:     strncpy(value, ACL_DEFAULT, len);
                     94:     return 0;
                     95: }
                     96: 
                     97: static int mp_dacl_setxattr(FsContext *ctx, const char *path, const char *name,
                     98:                             void *value, size_t size, int flags)
                     99: {
                    100:     return lsetxattr(rpath(ctx, path), MAP_ACL_DEFAULT, value, size, flags);
                    101: }
                    102: 
                    103: static int mp_dacl_removexattr(FsContext *ctx,
                    104:                                const char *path, const char *name)
                    105: {
                    106:     return lremovexattr(rpath(ctx, path), MAP_ACL_DEFAULT);
                    107: }
                    108: 
                    109: 
                    110: XattrOperations mapped_pacl_xattr = {
                    111:     .name = "system.posix_acl_access",
                    112:     .getxattr = mp_pacl_getxattr,
                    113:     .setxattr = mp_pacl_setxattr,
                    114:     .listxattr = mp_pacl_listxattr,
                    115:     .removexattr = mp_pacl_removexattr,
                    116: };
                    117: 
                    118: XattrOperations mapped_dacl_xattr = {
                    119:     .name = "system.posix_acl_default",
                    120:     .getxattr = mp_dacl_getxattr,
                    121:     .setxattr = mp_dacl_setxattr,
                    122:     .listxattr = mp_dacl_listxattr,
                    123:     .removexattr = mp_dacl_removexattr,
                    124: };
                    125: 
                    126: XattrOperations passthrough_acl_xattr = {
                    127:     .name = "system.posix_acl_",
                    128:     .getxattr = pt_getxattr,
                    129:     .setxattr = pt_setxattr,
                    130:     .listxattr = pt_listxattr,
                    131:     .removexattr = pt_removexattr,
                    132: };
                    133: 
                    134: XattrOperations none_acl_xattr = {
                    135:     .name = "system.posix_acl_",
                    136:     .getxattr = notsup_getxattr,
                    137:     .setxattr = notsup_setxattr,
                    138:     .listxattr = notsup_listxattr,
                    139:     .removexattr = notsup_removexattr,
                    140: };

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.