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