src/vconf-buxton-tool.sh

   1 #!/bin/bash
   2 #
   3 #     This script emulate the behaviour of vconftool
   4 #
   5 # author: jose.bollo@open.eurogiciel.org
   6
   7 exe="$(basename "$0")"
   8 verbose=false
   9 quiet=false
  10
  11 #
  12 # prompting
  13 #
  14 if [[ -t 1 ]]
  15 then
  16   reset=$(printf '\e[0m')
  17   red=$(printf '\e[1;31m')
  18   yellow=$(printf '\e[1;33m')
  19   green=$(printf '\e[1;32m')
  20 else
  21   reset=
  22   red=
  23   yellow=
  24   green=
  25 fi
  26
  27 info() {
  28   $verbose && echo "${green}$*${reset}"
  29   return 0
  30 }
  31
  32 warning() {
  33   $quiet || echo "${yellow}WARNING: $*${reset}"
  34   return 0
  35 }
  36
  37 error() {
  38   $quiet || echo "${red}ERROR: $*${reset}" >&2
  39   return 1
  40 }
  41
  42 badargs() {
  43   local cmd="$1"
  44   shift
  45   error "$exe $cmd: bad arguments $*"
  46   exit
  47 }
  48
  49 #
  50 # calls to buxton
  51 #
  52 buxmode=$(pgrep buxtond >/dev/null 2>&1 && echo -n -s || echo -n -d)
  53 buxton() {
  54   buxtonctl $buxmode -- "$@"
  55 }
  56
  57 buxton_is_ready() {
  58   buxton check > /dev/null
  59 }
  60
  61 buxton_has_group() {
  62   local layer="$1" group="$2"
  63   buxton list-groups "${layer}" 2>/dev/null |
  64   grep -q "found group ${group}\$"
  65 }
  66
  67 buxton_has_key() {
  68   local layer="$1" group="$2" name="$3"
  69   buxton list-keys "${layer}" "${group}" 2>/dev/null |
  70   grep -q "found key ${name}\$"
  71 }
  72
  73 buxton_make_group() {
  74   local layer="$1" group="$2"
  75   if buxton create-group "$layer" "$group" > /dev/null
  76   then
  77     info "group $group succesfully created for layer $layer"
  78   else
  79     error "can not create group $group for layer $layer"
  80   fi
  81 }
  82
  83 buxton_get_label() {
  84   if [[ $# -eq 2 ]]
  85   then
  86     local layer="$1" group="$2" result=
  87     if ! result=$(buxton get-label "$layer" "$group" 2> /dev/null |
  88                   grep "\[$layer] $group:(null) - " |
  89                   sed 's:.* - ::')
  90     then
  91       error "can not get the label $label of group $group of layer $layer"
  92     elif [[ -z "$result" ]]
  93     then
  94       error "invalid label gotten for group $group of layer $layer"
  95     else
  96       echo -n "$result"
  97     fi
  98   else
  99     local layer="$1" group="$2" name="$3" result=
 100     if ! result=$(buxton get-label "$layer" "$group" "$name" 2> /dev/null |
 101                   grep "\[$layer] $group:$name - " |
 102                   sed 's:.* - ::')
 103     then
 104       error "can not get the label $label of key $name in group $group of layer $layer"
 105     elif [[ -z "$result" ]]
 106     then
 107       error "invalid label gotten for key $name in group $group of layer $layer"
 108     else
 109       echo -n "$result"
 110     fi
 111   fi
 112 }
 113
 114 buxton_set_label() {
 115   if [[ $# -eq 3 ]]
 116   then
 117     local layer="$1" group="$2" label="$3"
 118     if ! buxton set-label "$layer" "$group" "$label" > /dev/null
 119     then
 120       error "can not set label $label to group $group of layer $layer"
 121     elif [[ "$label" != "$(buxton_get_label "$layer" "$group")" ]]
 122     then
 123       error "check failed when setting label $label to group $group of layer $layer"
 124     else
 125       info "label $label set to group $group of layer $layer"
 126     fi
 127   else
 128     local layer="$1" group="$2" name="$3" label="$4"
 129     if ! buxton set-label "$layer" "$group" "$name" "$label" > /dev/null
 130     then
 131       error "can not set label $label to key $name in group $group of layer $layer"
 132     elif [[ "$label" != "$(buxton_get_label "$layer" "$group" "$name")" ]]
 133     then
 134       error "check failed when setting label $label to key $name in group $group of layer $layer"
 135     else
 136       info "label $label set to key $name in group $group of layer $layer"
 137     fi
 138   fi
 139 }
 140
 141 buxton_ensure_group() {
 142   local layer="$1" group="$2" label="$3"
 143   if buxton_has_group "$layer" "$group"
 144   then
 145     info "group $group exists in layer $layer"
 146   else
 147     buxton_make_group "$layer" "$group" || return
 148   fi
 149   [[ -z "$label" ]] || buxton_set_label "$layer" "$group" "$label"
 150 }
 151
 152 buxton_ensure_ready() {
 153   if ! buxton_is_ready
 154   then
 155     error "can not connect to buxton service"
 156     exit
 157   fi
 158 }
 159
 160 buxton_unset() {
 161   local layer="$1" group="$2" name="$3"
 162
 163   # unset the value
 164   if ! buxton_has_key "$layer" "$group" "$name"
 165   then
 166     info "key $name in group $group of layer $layer is already unset"
 167   elif ! buxton "unset-value" "$layer" "$group" "$name" > /dev/null
 168   then
 169     error "can not unset key $name in group $group of layer $layer"
 170   elif buxton_has_key "$layer" "$group" "$name"
 171   then
 172     error "check failed when unsetting key $name in group $group of layer $layer"
 173   else
 174     info "key $name in group $group of layer $layer is unset"
 175   fi
 176   exit
 177 }
 178
 179 #############################################################################################
 180
 181 group=vconf
 182
 183
 184 # get the layer of the key
 185 layer_of_key() {
 186   case "$1/" in
 187   user/*) echo -n "user";;
 188   memory/*)
 189     if [[ "$buxmode" = '-d' ]]
 190     then
 191       error "the layer temp isn't available in direct mode"
 192       exit
 193     fi
 194     echo -n "temp"
 195     ;;
 196   *) echo -n "base";;
 197   esac
 198 }
 199
 200 # get the standard value
 201 stdval() {
 202   local typ="$1" val="$2"
 203   case "$typ:${val,,}" in
 204   bool:0|bool:false|bool:off) echo -n "false";;
 205   bool:1|bool:true|bool:on) echo -n "true";;
 206   *) echo -n "$val";;
 207   esac
 208 }
 209
 210 # get buxton-type from vconf-type
 211 v2btype() {
 212   case "${1,,}" in
 213   int) echo -n "int32";;
 214   string) echo -n "string";;
 215   double) echo -n "double";;
 216   bool) echo -n "bool";;
 217   *) error "unknown vconf-type $1"; exit;;
 218   esac
 219 }
 220
 221 # get vconf-type from buxton-type
 222 b2vtype() {
 223   case "${1,,}" in
 224   int32) echo -n "int";;
 225   string) echo -n "string";;
 226   double) echo -n "double";;
 227   bool) echo -n "bool";;
 228   *) error "unknown buxton-type $1"; exit;;
 229   esac
 230 }
 231
 232 #set a key
 233 setkey() {
 234   local typ="$1" name="$2" value="$3" smack="$4" layer=
 235
 236   layer="$(layer_of_key "$name")"
 237   typ="$(v2btype "$typ")"
 238   value="$(stdval "$typ" "$value")"
 239
 240   if buxton "set-$typ" "$layer" "$group" "$name" "$value" > /dev/null
 241   then
 242     info "key $name in group $group of layer $layer set to $typ: $value"
 243     [[ -z "$smack" ]] || buxton_set_label "$layer" "$group" "$name" "$smack"
 244   else
 245     error "can not set key $name in group $group of layer $layer with $typ: $value"
 246   fi
 247 }
 248
 249 # calls getopt with negative numbers protection
 250 mygetopt() {
 251   local name="$exe $1" long="$2" short="$3" x=
 252   shift 3
 253   eval set -- $(
 254     for x; do
 255       echo -n "'$x'" |
 256       sed "s:\(.\)'\(.\):\\1\\\\'\\2:g ; s/^'\(-[0-9.]*\)'\$/'protect-sign:\1'/ ; s/^.*/& /"
 257     done
 258   )
 259   getopt -n "$name" -l "$long" -o "$short" -- "$@" |
 260   sed "s/'protect-sign:/'/g"
 261 }
 262
 263 #
 264 # ensure existing the group for vconf
 265 #
 266 buxton_ensure_group "base" "$group" || exit
 267
 268 # set the value
 269 doset() {
 270   local typ= name= layer= value= smack= force=false instal=false
 271
 272   # scan arguments
 273   eval set -- $(mygetopt set force,install,type:,smack:,group:,user: fit:s:g:u: "$@")
 274   while :
 275   do
 276     case "$1" in
 277     -t|--type)
 278       typ="$2"
 279       shift 2
 280       ;;
 281     -s|--smack)
 282       smack="$2"
 283       shift 2
 284       ;;
 285     -f|--force)
 286       force=true
 287       shift
 288       ;;
 289     -i|--install)
 290       instal=true
 291       shift
 292       ;;
 293     -u|-g|--user|--group)
 294       info "option $1 $2 ignored!"
 295       shift 2
 296       ;;
 297     --)
 298       shift
 299       break
 300       ;;
 301     *)
 302       badargs set "$*"
 303       ;;
 304     esac
 305   done
 306   [[ "$#" -eq 2 ]] || badargs set "$*"
 307   name="$1"
 308   value="$2"
 309   [[ -n "$typ" ]] || badargs set no type given
 310   [[ -n "$name" ]] || badargs set no keyname given
 311
 312   # process
 313   if $instal
 314   then
 315     if expr "$name" : memory/ >/dev/null
 316     then
 317       setkey "$typ" "memory_init/$name" "$value" "$smack" || exit
 318       [[ "$buxmode" = -d ]] && exit
 319     else
 320       warning only keys beginning with memory/ are allowing option -i
 321     fi
 322   fi
 323   setkey "$typ" "$name" "$value" "$smack"
 324   exit
 325 }
 326
 327 # get the value
 328 doget() {
 329   local name= layer= rec=false val=
 330
 331   # scan arguments
 332   eval set -- $(mygetopt get recursive r "$@")
 333   if [[ "$1" = "-r" || "$1" = "--recursive" ]]
 334   then
 335     rec=true
 336     shift
 337   fi
 338   [[ "$1" = -- ]] || badargs get unexpected error
 339   shift
 340   [[ $# -eq 1 && -n "$1" ]] || badargs get "$@"
 341   name="$1"
 342
 343   # process
 344   layer="$(layer_of_key "$name")"
 345   if $rec
 346   then
 347     set -- $(buxton list-keys "$layer" "$group" "$name" 2> /dev/null |
 348              grep "found key" |
 349              sed 's:.* ::')
 350   else
 351     set -- "$name"
 352   fi
 353   for name
 354   do
 355     val="$(buxton get "$layer" "$group" "$name" 2> /dev/null |
 356          grep "\[$layer] $group:$name = " |
 357          sed 's/.* = // ; s/^int32:/int:/ ; s/^\(.*\): \(.*\)$/\2 (\1)/')"
 358     if [[ -z "$val" ]]
 359     then
 360       error "key $name not found in group $group of layer $layer"
 361     else
 362       echo "$name, value = $val"
 363     fi
 364   done
 365   exit
 366 }
 367
 368 # unset the value
 369 dounset() {
 370   local name= layer=
 371
 372   # scan arguments
 373   [[ $# -eq 1 && -n "$name" ]] || badargs unset
 374   name="$1"
 375   layer="$(layer_of_key "$name")"
 376
 377   # process
 378   buxton_unset "$layer" "$group" "$name"
 379   exit
 380 }
 381
 382 # set the label
 383 dolabel() {
 384   local name= smack= layer=
 385
 386   # scan arguments
 387   [[ $# -eq 2 && -n "$name" && -n "$smack" ]] || badargs label
 388   name="$1"
 389   smack="$2"
 390   layer="$(layer_of_key "$name")"
 391
 392   # process
 393   buxton_set_label "$layer" "$group" "$name"
 394   exit
 395 }
 396
 397
 398
 399
 400
 401
 402 cmd="${1,,}"
 403 shift
 404
 405 case "${cmd}" in
 406 -v|--verbose) verbose=true; cmd="${1,,}"; shift;;
 407 -q|--quiet) quiet=true; cmd="${1,,}"; shift;;
 408 esac
 409
 410 case "${cmd}" in
 411 get) doget "$@";;
 412 set) doset "$@";;
 413 unset) dounset "$@";;
 414 label) dolabel "$@";;
 415 help|-h|--help) cat << EOC
 416
 417 Usage: $exe [-v|--verbose|-q|--quiet] command ...
 418
 419 Command set: set a value (create or update)
 420
 421    $exe set -t <TYPE> <KEY-NAME> <VALUE> <OPTIONS>
 422
 423        <TYPE> = int | bool | double | string
 424
 425        <OPTIONS>
 426
 427           -u, --user    <UID>    ignored! (compatibility)
 428           -g, --group   <GID>    ignored! (compatibility)
 429           -i, --install          for keys starting with memory/
 430                                  installs in db the startup value
 431           -s, --smack   <LABEL>  tells to set the security label <LABEL>
 432           -f, --force            tells force updating the value
 433
 434        Ex) $exe set -t string db/testapp/key1 "This is test"
 435
 436 Command get: get a value
 437
 438    $exe get <OPTIONS> <KEY-NAME>
 439
 440        <OPTIONS>
 441
 442           -r, --recursive        retrieve all keys having the given prefix
 443
 444        Ex) $exe get db/testapp/key1
 445            $exe get -r db/testapp/
 446
 447 Command unset: remove a value
 448
 449    $exe unset <KEY-NAME>
 450
 451        Ex) $exe unset db/testapp/key1
 452
 453 Command label: set the security label
 454
 455    $exe label <KEY-NAME> <SMACK-LABEL>
 456
 457        Ex) $exe label db/testapp/key1 User::Share
 458
 459 EOC
 460 esac
 461