Changeset 134

Show
Ignore:
Timestamp:
03/11/06 23:11:04 (3 years ago)
Author:
bonbons
Message:

Fixed BCAPS limited to initial minimal subset, now they are set by vcontext (ored with default minimal subset)

Note: BCAPS are not reset on processes running in guest! Only SUID processes started after BCAPS change or
processes migrated after that change will see new BCAPS.

Fixed some incorrect printfs(.%lx.., uint64) which should have been printfs(.%llx.., uint64)

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • branches/1.0.4/scripts/lib/vps.sh

    r133 r134  
    101101        case ${subcmd} in 
    102102                setup) 
     103                        VCTX_ARGS="-x ${VX_XID}" 
     104                        [ ! -z "${VX_BCAPS}" ] && VCTX_ARGS="${VCTX_ARGS} -b $(util.array_to_list ${VX_BCAPS[@]})" 
     105                        [ ! -z "${VX_CCAPS}" ] && VCTX_ARGS="${VCTX_ARGS} -c $(util.array_to_list ${VX_CCAPS[@]})" 
     106                        if [ ! -z "${VX_FLAGS}" ]; then 
     107                                VCTX_ARGS="${VCTX_ARGS} -f $(util.array_to_list ${VX_FLAGS[@]}),PERSISTANT,STATE_SETUP" 
     108                        else 
     109                                VCTX_ARGS="${VCTX_ARGS} -f PERSISTANT,STATE_SETUP" 
     110                        fi 
    103111                        ${_VNCONTEXT} -C -n ${VX_XID} -f PERSISTANT,STATE_SETUP 
    104                         ${_VCONTEXT} -C -x ${VX_XID} -f PERSISTANT,STATE_SETUP 
     112                        ${_VCONTEXT} -C ${VCTX_ARGS} 
    105113                        ;; 
    106114                 
     
    231239        case ${subcmd} in 
    232240                set) 
    233                       if [ ! -z "${VX_BCAPS}" ]; then 
    234                               ${_VFLAGS} -S -b $(util.array_to_list ${VX_BCAPS[@]}) -x ${VX_XID} 
    235                       fi 
    236                       if [ ! -z "${VX_CCAPS}" ]; then 
    237                               ${_VFLAGS} -S -c $(util.array_to_list ${VX_CCAPS[@]}) -x ${VX_XID} 
    238                       fi 
    239                       if [ ! -z "${VX_FLAGS}" ]; then 
    240                               ${_VFLAGS} -S -f $(util.array_to_list ${VX_FLAGS[@]}),PERSISTANT -x ${VX_XID} 
    241                       fi 
     241#                     if [ ! -z "${VX_BCAPS}" ]; then 
     242#                             ${_VFLAGS} -S -b $(util.array_to_list ${VX_BCAPS[@]}) -x ${VX_XID} 
     243#                     fi 
     244#                     if [ ! -z "${VX_CCAPS}" ]; then 
     245#                             ${_VFLAGS} -S -c $(util.array_to_list ${VX_CCAPS[@]}) -x ${VX_XID} 
     246#                     fi 
     247#                     if [ ! -z "${VX_FLAGS}" ]; then 
     248#                             ${_VFLAGS} -S -f $(util.array_to_list ${VX_FLAGS[@]}),PERSISTANT -x ${VX_XID} 
     249#                     fi 
    242250                        ;; 
    243251                 
  • branches/1.0.4/src/tools/vcontext.c

    r130 r134  
    4545        command_t cmd; 
    4646        xid_t xid; 
    47         list_t *flags; 
    48         list_t *bcaps; 
    49         list_t *ccaps; 
    50         list_t *mflags; 
     47        uint64_t flags; 
     48        uint64_t fmask; 
     49        uint64_t bcaps; 
     50        uint64_t bmask; 
     51        uint64_t ccaps; 
     52        uint64_t cmask; 
     53        uint64_t mflags; 
     54        uint64_t mmask; 
    5155}; 
    5256 
     
    6771               "    -b <list>     Set bcaps described in <list>\n" 
    6872               "    -c <list>     Set ccaps described in <list>\n" 
    69 /*             "    -m <list>     Set migration flags described in <list>\n" */ 
     73               "    -m <list>     Set migration flags described in <list>\n" 
    7074               "\n" 
    7175               "Flag list format string:\n" 
     
    7882} 
    7983 
     84#define delim ',' // list delimiter 
     85#define clmod '~' // clear flag modifier 
     86 
     87int calc_caps(const char*lst, list_t *vals, uint64_t *flags, uint64_t *fmask) 
     88{ 
     89        list_link_t link = { 
     90                .p = vals, 
     91                .d = list_parse_list(lst, delim), 
     92        }; 
     93         
     94        /* validate descending list */ 
     95        if (list_validate_flag(&link, clmod) == -1) 
     96                return -1; 
     97         
     98        /* convert given descending list to flags using the pristine copy */ 
     99        list_list2flags(&link, clmod, flags, fmask); 
     100        return 0; 
     101} 
     102 
    80103int main(int argc, char *argv[]) 
    81104{ 
    82105        struct options opts = { 
    83106                GLOBAL_OPTS_INIT, 
    84                 .cmd   = VCTX_NONE, 
    85                 .xid   = (~0U), 
    86                 .flags = 0, 
     107                .cmd    = VCTX_NONE, 
     108                .xid    = (~0U), 
     109                .flags  = 0, 
     110                .fmask  = 0, 
     111                .ccaps  = 0, 
     112                .cmask  = 0, 
     113                .bcaps  = 0, 
     114                .bmask  = 0, 
     115                .mflags = 0, 
     116                .mmask  = 0, 
    87117        }; 
    88118         
    89119        struct vx_info info; 
    90120         
     121        list_t *fp = cflags_list_init(); 
     122        list_t *bp = bcaps_list_init(); 
     123        list_t *cp = ccaps_list_init(); 
     124        list_t *mp = mflags_list_init(); 
     125         
    91126        int c; 
    92         const char delim = ','; // list delimiter 
    93         const char clmod = '~'; // clear flag modifier 
    94127         
    95128        DEBUGF("%s: starting ...\n", NAME); 
     
    129162                         
    130163                        case 'f': 
    131                                 opts.flags = list_parse_list(optarg, delim); 
     164                                if (calc_caps(optarg, fp, &opts.flags, &opts.fmask) == -1) 
     165                                        PEXIT("List validation failed for FLAGS", EXIT_USAGE); 
    132166                                break; 
    133167                         
    134168                        case 'c': 
    135                                 opts.ccaps = list_parse_list(optarg, delim); 
     169                                if (calc_caps(optarg, cp, &opts.ccaps, &opts.cmask) == -1) 
     170                                        PEXIT("List validation failed for CCAPS", EXIT_USAGE); 
    136171                                break; 
    137172                                 
    138173                        case 'b': 
    139                                 opts.bcaps = list_parse_list(optarg, delim); 
     174                                if (calc_caps(optarg, bp, &opts.bcaps, &opts.bmask) == -1) 
     175                                        PEXIT("List validation failed for BCAPS", EXIT_USAGE); 
    140176                                break; 
    141177                                 
    142178                        case 'm': 
    143                                 opts.mflags = list_parse_list(optarg, delim); 
     179                                if (calc_caps(optarg, mp, &opts.mflags, &opts.mmask) == -1) 
     180                                        PEXIT("List validation failed for MFLAGS", EXIT_USAGE); 
    144181                                break; 
    145182                         
     
    151188                case VCTX_CREATE: { 
    152189                        struct vx_create_flags create_flags = { 
    153                                 .flags = VXF_STATE_SETUP
     190                                .flags = VXF_STATE_SETUP | opts.flags
    154191                        }; 
    155                         if (opts.flags) { 
    156                                 /* init flags list */ 
    157                                 list_t *cp = cflags_list_init(); 
    158  
    159                                 list_link_t link = { 
    160                                         .p = cp, 
    161                                         .d = opts.flags, 
    162                                 }; 
    163                                 uint64_t fmask = 0; 
    164                                  
    165                                 /* validate descending list */ 
    166                                 if (list_validate_flag(&link, clmod) == -1) 
    167                                         PEXIT("List validation failed for FLAGS", EXIT_USAGE); 
    168                          
    169                                 /* convert given descending list to flags using the pristine copy */ 
    170                                 list_list2flags(&link, clmod, &create_flags.flags, &fmask); 
    171                                 create_flags.flags |= VXF_STATE_SETUP; 
    172                         } 
    173192                         
    174193                        /* syscall */ 
     
    177196                         
    178197                        /* Set as default values those used by util-vserver */ 
    179                         if (opts.ccaps == NULL) opts.ccaps = list_parse_list("SET_UTSNAME,RAW_ICMP", delim); 
    180                         if (opts.bcaps == NULL) opts.bcaps = list_parse_list("CHOWN,DAC_OVERRIDE,DAC_READ_SEARCH," 
     198                        uint64_t defcaps; 
     199                        uint64_t defmcaps; 
     200                        struct vx_caps caps = { 
     201                                .bcaps = 0, 
     202                                .ccaps = 0, 
     203                                .cmask = 0, 
     204                        }; 
     205 
     206                        if (calc_caps("SET_UTSNAME,RAW_ICMP", cp, &defcaps, &defmcaps) == -1) 
     207                                PEXIT("List validation failed for default CCAPS", EXIT_USAGE); 
     208                        caps.ccaps = (opts.ccaps & opts.cmask) | (defcaps & defmcaps & ~opts.cmask); 
     209                        caps.cmask = opts.cmask | defmcaps; 
     210                         
     211                        if (calc_caps("CHOWN,DAC_OVERRIDE,DAC_READ_SEARCH," 
    181212                                        "FOWNER,FSETID,FS_MASK,KILL,SETGID,SETUID,NET_BIND_SERVICE,SYS_CHROOT," 
    182                                         "SYS_PTRACE,SYS_BOOT,SYS_TTY_CONFIG,LEASE,SYS_ADMIN", delim); 
    183                         if (opts.ccaps || opts.bcaps) { 
    184                                 struct vx_caps caps = { 
    185                                         .bcaps = 0, 
    186                                         .ccaps = 0, 
    187                                         .cmask = 0, 
    188                                 }; 
    189                                 list_t *bp = bcaps_list_init(); 
    190                                 list_t *cp = ccaps_list_init(); 
    191                                  
    192                                 list_link_t link = { 
    193                                         .p = bp, 
    194                                         .d = opts.bcaps, 
    195                                 }; 
    196  
    197                                 /* validate descending list */ 
    198                                 if (list_validate_flag(&link, clmod) == -1) 
    199                                         PEXIT("List validation failed for BCAPS", EXIT_USAGE); 
    200                                 /* convert given descending list to flags using the pristine copy */ 
    201                                 list_list2flags(&link, clmod, &caps.bcaps, &caps.cmask); 
    202  
    203                                 link.p = cp; 
    204                                 link.d = opts.ccaps; 
    205                                 /* validate descending list */ 
    206                                 if (list_validate_flag(&link, clmod) == -1) 
    207                                         PEXIT("List validation failed for CCAPS", EXIT_USAGE); 
    208                                 /* convert given descending list to flags using the pristine copy */ 
    209                                 list_list2flags(&link, clmod, &caps.ccaps, &caps.cmask); 
    210  
    211                                 /* Finally set the caps */ 
    212                                 if (vx_set_caps(opts.xid, &caps) == -1) 
    213                                         PEXIT("Failed to set context capabilities", EXIT_COMMAND); 
    214                         } 
     213                                        "SYS_PTRACE,SYS_BOOT,SYS_TTY_CONFIG,LEASE", bp, &defcaps, &defmcaps) == -1) 
     214                                PEXIT("List validation failed for default BCAPS", EXIT_USAGE); 
     215                        caps.bcaps = (opts.bcaps & opts.bmask) | (defcaps & defmcaps & ~opts.bmask); 
     216                         
     217                        /* Finally set the caps */ 
     218                        if (vx_set_caps(opts.xid, &caps) == -1) 
     219                                PEXIT("Failed to set context capabilities", EXIT_COMMAND); 
     220                         
    215221                        if (argc > optind) { 
    216222                                struct vx_flags flags = { 
     
    225231                case VCTX_MIGRATE: { 
    226232                        struct vx_migrate_flags migrate_flags = { 
    227                                 .flags = 0
     233                                .flags = opts.mflags
    228234                        }; 
    229235 
    230                         if (opts.mflags) { 
    231                                 /* init flags list */ 
    232                                 list_t *mp = mflags_list_init(); 
    233                                  
    234                                 list_link_t link = { 
    235                                         .p = mp, 
    236                                         .d = opts.mflags, 
    237                                 }; 
    238                                 uint64_t fmask = 0; 
    239                                  
    240                                 /* validate descending list */ 
    241                                 if (list_validate_flag(&link, clmod) == -1) 
    242                                         PEXIT("List validation failed", EXIT_USAGE); 
    243                                  
    244                                 /* convert given descending list to flags using the pristine copy */ 
    245                                 list_list2flags(&link, clmod, &migrate_flags.flags, &fmask); 
    246                         } 
    247236                        /* syscall */ 
    248237                        if (vx_migrate(opts.xid, &migrate_flags) == -1) 
  • branches/1.0.4/src/tools/vexec.c

    r132 r134  
    180180                        } 
    181181                         
    182                         DEBUGF("Migrating with mflags=%lx\n", mflags.flags); 
     182                        DEBUGF("Migrating with mflags=%llx\n", mflags.flags); 
    183183                        if (vx_migrate(opts.xid, &mflags) == -1) 
    184184                                PEXIT("Failed to migrate to context", EXIT_COMMAND); 
     
    192192                                        perror("Failed to stat /dev/console"); 
    193193                                } else if (S_ISCHR(st.st_mode)) { 
    194                                         int fd = open("/dev/console", O_RDWR); // O_NOCTTY); 
     194                                        int fd = open("/dev/console", O_RDWR | O_NOCTTY); 
    195195                                        if (fd < 0) { 
    196196                                                vu_dprintf(STDERR_FILENO, "Failed to open /dev/console:  %s\n", strerror(errno)); 
  • branches/1.0.4/src/tools/vflags.c

    r130 r134  
    189189                                        PEXIT("List validation failed", EXIT_USAGE); 
    190190                 
     191                                caps.bcaps = 0; 
     192                                bmask = 0; 
    191193                                /* convert given descending list to flags using the pristine copy */ 
    192194                                list_list2flags(&blink, clmod, &caps.bcaps, &bmask); 
     
    210212                        /* syscall */ 
    211213                        if (bmask || caps.cmask) { 
    212                                 DEBUGF("BCaps = %.16lx, old  = %.16lx\n", caps.bcaps, obcaps); 
    213                                 DEBUGF("CCaps = %.16lx, mask = %.16lx\n", caps.ccaps, caps.cmask); 
     214                                DEBUGF("BCaps = %.16llx, old  = %.16llx\n", caps.bcaps, obcaps); 
     215                                DEBUGF("CCaps = %.16llx, mask = %.16llx\n", caps.ccaps, caps.cmask); 
    214216                                if (vx_set_caps(opts.xid, &caps) == -1) 
    215217                                        PEXIT("Failed to set context capabilities", EXIT_COMMAND); 
     
    244246                                PEXIT("Failed to get context flags", EXIT_COMMAND); 
    245247                         
    246                         VPRINTF(&opts, "Flage = %.16lx\n", flags.flags); 
    247                         VPRINTF(&opts, "BCaps = %.16lx\n", caps.bcaps); 
    248                         VPRINTF(&opts, "CCaps = %.16lx\n", caps.ccaps); 
     248                        VPRINTF(&opts, "Flags = %.16llx\n", flags.flags); 
     249                        VPRINTF(&opts, "BCaps = %.16llx\n", caps.bcaps); 
     250                        VPRINTF(&opts, "CCaps = %.16llx\n", caps.ccaps); 
    249251                         
    250252                        if (opts.compact) {