package/system/procd/files/procd.sh

   1 # procd API:
   2 #
   3 # procd_open_service(name, [script]):
   4 #   Initialize a new procd command message containing a service with one or more instances
   5 #
   6 # procd_close_service()
   7 #   Send the command message for the service
   8 #
   9 # procd_open_instance([name]):
  10 #   Add an instance to the service described by the previous procd_open_service call
  11 #
  12 # procd_set_param(type, [value...])
  13 #   Available types:
  14 #     command: command line (array).
  15 #     respawn info: array with 3 values $fail_threshold $restart_timeout $max_fail
  16 #     env: environment variable (passed to the process)
  17 #     data: arbitrary name/value pairs for detecting config changes (table)
  18 #     file: configuration files (array)
  19 #     netdev: bound network device (detects ifindex changes)
  20 #     limits: resource limits (passed to the process)
  21 #     user: $username to run service as
  22 #     group: $groupname to run service as
  23 #     pidfile: file name to write pid into
  24 #     stdout: boolean whether to redirect commands stdout to syslog (default: 0)
  25 #     stderr: boolean whether to redirect commands stderr to syslog (default: 0)
  26 #     facility: syslog facility used when logging to syslog (default: daemon)
  27 #
  28 #   No space separation is done for arrays/tables - use one function argument per command line argument
  29 #
  30 # procd_close_instance():
  31 #   Complete the instance being prepared
  32 #
  33 # procd_running(service, [instance]):
  34 #   Checks if service/instance is currently running
  35 #
  36 # procd_kill(service, [instance]):
  37 #   Kill a service instance (or all instances)
  38 #
  39 # procd_send_signal(service, [instance], [signal])
  40 #   Send a signal to a service instance (or all instances)
  41 #
  42
  43 . "$IPKG_INSTROOT/usr/share/libubox/jshn.sh"
  44
  45 PROCD_RELOAD_DELAY=1000
  46 _PROCD_SERVICE=
  47
  48 procd_lock() {
  49         local basescript=$(readlink "$initscript")
  50         local service_name="$(basename ${basescript:-$initscript})"
  51
  52         flock -n 1000 &> /dev/null
  53         if [ "$?" != "0" ]; then
  54                 exec 1000>"$IPKG_INSTROOT/var/lock/procd_${service_name}.lock"
  55                 flock 1000
  56                 if [ "$?" != "0" ]; then
  57                         logger "warning: procd flock for $service_name failed"
  58                 fi
  59         fi
  60 }
  61
  62 _procd_call() {
  63         local old_cb
  64
  65         json_set_namespace procd old_cb
  66         "$@"
  67         json_set_namespace $old_cb
  68 }
  69
  70 _procd_wrapper() {
  71         procd_lock
  72         while [ -n "$1" ]; do
  73                 eval "$1() { _procd_call _$1 \"\$@\"; }"
  74                 shift
  75         done
  76 }
  77
  78 _procd_ubus_call() {
  79         local cmd="$1"
  80
  81         [ -n "$PROCD_DEBUG" ] && json_dump >&2
  82         ubus call service "$cmd" "$(json_dump)"
  83         json_cleanup
  84 }
  85
  86 _procd_open_service() {
  87         local name="$1"
  88         local script="$2"
  89
  90         _PROCD_SERVICE="$name"
  91         _PROCD_INSTANCE_SEQ=0
  92
  93         json_init
  94         json_add_string name "$name"
  95         [ -n "$script" ] && json_add_string script "$script"
  96         json_add_object instances
  97 }
  98
  99 _procd_close_service() {
 100         json_close_object
 101         _procd_open_trigger
 102         service_triggers
 103         _procd_close_trigger
 104         _procd_open_data
 105         service_data
 106         _procd_close_data
 107         _procd_ubus_call ${1:-set}
 108 }
 109
 110 _procd_add_array_data() {
 111         while [ "$#" -gt 0 ]; do
 112                 json_add_string "" "$1"
 113                 shift
 114         done
 115 }
 116
 117 _procd_add_array() {
 118         json_add_array "$1"
 119         shift
 120         _procd_add_array_data "$@"
 121         json_close_array
 122 }
 123
 124 _procd_add_table_data() {
 125         while [ -n "$1" ]; do
 126                 local var="${1%%=*}"
 127                 local val="${1#*=}"
 128                 [ "$1" = "$val" ] && val=
 129                 json_add_string "$var" "$val"
 130                 shift
 131         done
 132 }
 133
 134 _procd_add_table() {
 135         json_add_object "$1"
 136         shift
 137         _procd_add_table_data "$@"
 138         json_close_object
 139 }
 140
 141 _procd_open_instance() {
 142         local name="$1"; shift
 143
 144         _PROCD_INSTANCE_SEQ="$(($_PROCD_INSTANCE_SEQ + 1))"
 145         name="${name:-instance$_PROCD_INSTANCE_SEQ}"
 146         json_add_object "$name"
 147         [ -n "$TRACE_SYSCALLS" ] && json_add_boolean trace "1"
 148 }
 149
 150 _procd_open_trigger() {
 151         let '_procd_trigger_open = _procd_trigger_open + 1'
 152         [ "$_procd_trigger_open" -gt 1 ] && return
 153         json_add_array "triggers"
 154 }
 155
 156 _procd_close_trigger() {
 157         let '_procd_trigger_open = _procd_trigger_open - 1'
 158         [ "$_procd_trigger_open" -lt 1 ] || return
 159         json_close_array
 160 }
 161
 162 _procd_open_data() {
 163         let '_procd_data_open = _procd_data_open + 1'
 164         [ "$_procd_data_open" -gt 1 ] && return
 165         json_add_object "data"
 166 }
 167
 168 _procd_close_data() {
 169         let '_procd_data_open = _procd_data_open - 1'
 170         [ "$_procd_data_open" -lt 1 ] || return
 171         json_close_object
 172 }
 173
 174 _procd_open_validate() {
 175         json_select ..
 176         json_add_array "validate"
 177 }
 178
 179 _procd_close_validate() {
 180         json_close_array
 181         json_select triggers
 182 }
 183
 184 _procd_add_jail() {
 185         json_add_object "jail"
 186         json_add_string name "$1"
 187
 188         shift
 189
 190         for a in $@; do
 191                 case $a in
 192                 log)    json_add_boolean "log" "1";;
 193                 ubus)   json_add_boolean "ubus" "1";;
 194                 procfs) json_add_boolean "procfs" "1";;
 195                 sysfs)  json_add_boolean "sysfs" "1";;
 196                 ronly)  json_add_boolean "ronly" "1";;
 197                 requirejail)    json_add_boolean "requirejail" "1";;
 198                 netns)  json_add_boolean "netns" "1";;
 199                 userns) json_add_boolean "userns" "1";;
 200                 cgroupsns)      json_add_boolean "cgroupsns" "1";;
 201                 esac
 202         done
 203         json_add_object "mount"
 204         json_close_object
 205         json_close_object
 206 }
 207
 208 _procd_add_jail_mount() {
 209         local _json_no_warning=1
 210
 211         json_select "jail"
 212         [ $? = 0 ] || return
 213         json_select "mount"
 214         [ $? = 0 ] || {
 215                 json_select ..
 216                 return
 217         }
 218         for a in $@; do
 219                 json_add_string "$a" "0"
 220         done
 221         json_select ..
 222         json_select ..
 223 }
 224
 225 _procd_add_jail_mount_rw() {
 226         local _json_no_warning=1
 227
 228         json_select "jail"
 229         [ $? = 0 ] || return
 230         json_select "mount"
 231         [ $? = 0 ] || {
 232                 json_select ..
 233                 return
 234         }
 235         for a in $@; do
 236                 json_add_string "$a" "1"
 237         done
 238         json_select ..
 239         json_select ..
 240 }
 241
 242 _procd_set_param() {
 243         local type="$1"; shift
 244
 245         case "$type" in
 246                 env|data|limits)
 247                         _procd_add_table "$type" "$@"
 248                 ;;
 249                 command|netdev|file|respawn|watch|watchdog)
 250                         _procd_add_array "$type" "$@"
 251                 ;;
 252                 error)
 253                         json_add_array "$type"
 254                         json_add_string "" "$@"
 255                         json_close_array
 256                 ;;
 257                 nice|term_timeout)
 258                         json_add_int "$type" "$1"
 259                 ;;
 260                 reload_signal)
 261                         json_add_int "$type" $(kill -l "$1")
 262                 ;;
 263                 pidfile|user|group|seccomp|capabilities|facility|\
 264                 extroot|overlaydir|tmpoverlaysize)
 265                         json_add_string "$type" "$1"
 266                 ;;
 267                 stdout|stderr|no_new_privs)
 268                         json_add_boolean "$type" "$1"
 269                 ;;
 270         esac
 271 }
 272
 273 _procd_add_timeout() {
 274         [ "$PROCD_RELOAD_DELAY" -gt 0 ] && json_add_int "" "$PROCD_RELOAD_DELAY"
 275         return 0
 276 }
 277
 278 _procd_add_interface_trigger() {
 279         json_add_array
 280         _procd_add_array_data "$1"
 281         shift
 282
 283         json_add_array
 284         _procd_add_array_data "if"
 285
 286         json_add_array
 287         _procd_add_array_data "eq" "interface" "$1"
 288         shift
 289         json_close_array
 290
 291         json_add_array
 292         _procd_add_array_data "run_script" "$@"
 293         json_close_array
 294
 295         json_close_array
 296         _procd_add_timeout
 297         json_close_array
 298 }
 299
 300 _procd_add_reload_interface_trigger() {
 301         local script=$(readlink -f "$initscript")
 302
 303         _procd_open_trigger
 304         _procd_add_interface_trigger "interface.*" $1 "${script:-$initscript}" reload
 305         _procd_close_trigger
 306 }
 307
 308 _procd_add_config_trigger() {
 309         json_add_array
 310         _procd_add_array_data "$1"
 311         shift
 312
 313         json_add_array
 314         _procd_add_array_data "if"
 315
 316         json_add_array
 317         _procd_add_array_data "eq" "package" "$1"
 318         shift
 319         json_close_array
 320
 321         json_add_array
 322         _procd_add_array_data "run_script" "$@"
 323         json_close_array
 324
 325         json_close_array
 326         _procd_add_timeout
 327         json_close_array
 328 }
 329
 330 _procd_add_mount_trigger() {
 331         json_add_array
 332         _procd_add_array_data "$1"
 333         local action="$2"
 334         local multi=0
 335         shift ; shift
 336
 337         json_add_array
 338         _procd_add_array_data "if"
 339
 340         if [ "$2" ]; then
 341                 json_add_array
 342                 _procd_add_array_data "or"
 343                 multi=1
 344         fi
 345
 346         while [ "$1" ]; do
 347                 json_add_array
 348                 _procd_add_array_data "eq" "target" "$1"
 349                 shift
 350                 json_close_array
 351         done
 352
 353         [ $multi = 1 ] && json_close_array
 354
 355         json_add_array
 356         _procd_add_array_data "run_script" /etc/init.d/$name $action
 357         json_close_array
 358
 359         json_close_array
 360         _procd_add_timeout
 361         json_close_array
 362 }
 363
 364 _procd_add_action_mount_trigger() {
 365         local action="$1"
 366         shift
 367         local mountpoints="$(procd_get_mountpoints "$@")"
 368         [ "${mountpoints//[[:space:]]}" ] || return 0
 369         local script=$(readlink "$initscript")
 370         local name=$(basename ${script:-$initscript})
 371
 372         _procd_open_trigger
 373         _procd_add_mount_trigger mount.add $action "$mountpoints"
 374         _procd_close_trigger
 375 }
 376
 377 procd_get_mountpoints() {
 378         (
 379                 __procd_check_mount() {
 380                         local cfg="$1"
 381                         local path="${2%%/}/"
 382                         local target
 383                         config_get target "$cfg" target
 384                         target="${target%%/}/"
 385                         [ "$path" != "${path##$target}" ] && echo "${target%%/}"
 386                 }
 387                 local mpath
 388                 config_load fstab
 389                 for mpath in "$@"; do
 390                         config_foreach __procd_check_mount mount "$mpath"
 391                 done
 392         ) | sort -u
 393 }
 394
 395 _procd_add_restart_mount_trigger() {
 396         _procd_add_action_mount_trigger restart "$@"
 397 }
 398
 399 _procd_add_reload_mount_trigger() {
 400         _procd_add_action_mount_trigger reload "$@"
 401 }
 402
 403 _procd_add_raw_trigger() {
 404         json_add_array
 405         _procd_add_array_data "$1"
 406         shift
 407         local timeout=$1
 408         shift
 409
 410         json_add_array
 411         json_add_array
 412         _procd_add_array_data "run_script" "$@"
 413         json_close_array
 414         json_close_array
 415
 416         json_add_int "" "$timeout"
 417
 418         json_close_array
 419 }
 420
 421 _procd_add_reload_trigger() {
 422         local script=$(readlink -f "$initscript")
 423         local file
 424
 425         _procd_open_trigger
 426         for file in "$@"; do
 427                 _procd_add_config_trigger "config.change" "$file" "${script:-$initscript}" reload
 428         done
 429         _procd_close_trigger
 430 }
 431
 432 _procd_add_validation() {
 433         _procd_open_validate
 434         $@
 435         _procd_close_validate
 436 }
 437
 438 _procd_append_param() {
 439         local type="$1"; shift
 440         local _json_no_warning=1
 441
 442         json_select "$type"
 443         [ $? = 0 ] || {
 444                 _procd_set_param "$type" "$@"
 445                 return
 446         }
 447         case "$type" in
 448                 env|data|limits)
 449                         _procd_add_table_data "$@"
 450                 ;;
 451                 command|netdev|file|respawn|watch|watchdog)
 452                         _procd_add_array_data "$@"
 453                 ;;
 454                 error)
 455                         json_add_string "" "$@"
 456                 ;;
 457         esac
 458         json_select ..
 459 }
 460
 461 _procd_close_instance() {
 462         local respawn_vals
 463         _json_no_warning=1
 464         if json_select respawn ; then
 465                 json_get_values respawn_vals
 466                 if [ -z "$respawn_vals" ]; then
 467                         local respawn_threshold=$(uci_get system.@service[0].respawn_threshold)
 468                         local respawn_timeout=$(uci_get system.@service[0].respawn_timeout)
 469                         local respawn_retry=$(uci_get system.@service[0].respawn_retry)
 470                         _procd_add_array_data ${respawn_threshold:-3600} ${respawn_timeout:-5} ${respawn_retry:-5}
 471                 fi
 472                 json_select ..
 473         fi
 474
 475         json_close_object
 476 }
 477
 478 _procd_add_instance() {
 479         _procd_open_instance
 480         _procd_set_param command "$@"
 481         _procd_close_instance
 482 }
 483
 484 procd_running() {
 485         local service="$1"
 486         local instance="${2:-*}"
 487         [ "$instance" = "*" ] || instance="'$instance'"
 488
 489         json_init
 490         json_add_string name "$service"
 491         local running=$(_procd_ubus_call list | jsonfilter -l 1 -e "@['$service'].instances[$instance].running")
 492
 493         [ "$running" = "true" ]
 494 }
 495
 496 _procd_kill() {
 497         local service="$1"
 498         local instance="$2"
 499
 500         json_init
 501         [ -n "$service" ] && json_add_string name "$service"
 502         [ -n "$instance" ] && json_add_string instance "$instance"
 503         _procd_ubus_call delete
 504 }
 505
 506 _procd_send_signal() {
 507         local service="$1"
 508         local instance="$2"
 509         local signal="$3"
 510
 511         case "$signal" in
 512                 [A-Z]*) signal="$(kill -l "$signal" 2>/dev/null)" || return 1;;
 513         esac
 514
 515         json_init
 516         json_add_string name "$service"
 517         [ -n "$instance" -a "$instance" != "*" ] && json_add_string instance "$instance"
 518         [ -n "$signal" ] && json_add_int signal "$signal"
 519         _procd_ubus_call signal
 520 }
 521
 522 _procd_status() {
 523         local service="$1"
 524         local instance="$2"
 525         local data state
 526         local n_running=0
 527         local n_stopped=0
 528         local n_total=0
 529
 530         json_init
 531         [ -n "$service" ] && json_add_string name "$service"
 532
 533         data=$(_procd_ubus_call list | jsonfilter -e '@["'"$service"'"]')
 534         [ -z "$data" ] && { echo "inactive"; return 3; }
 535
 536         data=$(echo "$data" | jsonfilter -e '$.instances')
 537         if [ -z "$data" ]; then
 538                 [ -z "$instance" ] && { echo "active with no instances"; return 0; }
 539                 data="[]"
 540         fi
 541
 542         [ -n "$instance" ] && instance="\"$instance\"" || instance='*'
 543
 544         for state in $(jsonfilter -s "$data" -e '$['"$instance"'].running'); do
 545                 n_total=$((n_total + 1))
 546                 case "$state" in
 547                 false) n_stopped=$((n_stopped + 1)) ;;
 548                 true)  n_running=$((n_running + 1)) ;;
 549                 esac
 550         done
 551
 552         if [ $n_total -gt 0 ]; then
 553                 if [ $n_running -gt 0 ] && [ $n_stopped -eq 0 ]; then
 554                         echo "running"
 555                         return 0
 556                 elif [ $n_running -gt 0 ]; then
 557                         echo "running ($n_running/$n_total)"
 558                         return 0
 559                 else
 560                         echo "not running"
 561                         return 5
 562                 fi
 563         else
 564                 echo "unknown instance $instance"
 565                 return 4
 566         fi
 567 }
 568
 569 procd_open_data() {
 570         local name="$1"
 571         json_set_namespace procd __procd_old_cb
 572         json_add_object data
 573 }
 574
 575 procd_close_data() {
 576         json_close_object
 577         json_set_namespace $__procd_old_cb
 578 }
 579
 580 _procd_set_config_changed() {
 581         local package="$1"
 582
 583         json_init
 584         json_add_string type config.change
 585         json_add_object data
 586         json_add_string package "$package"
 587         json_close_object
 588
 589         ubus call service event "$(json_dump)"
 590 }
 591
 592 procd_add_mdns_service() {
 593         local service proto port
 594         service=$1; shift
 595         proto=$1; shift
 596         port=$1; shift
 597         json_add_object "${service}_$port"
 598         json_add_string "service" "_$service._$proto.local"
 599         json_add_int port "$port"
 600         [ -n "$1" ] && {
 601                 json_add_array txt
 602                 for txt in "$@"; do json_add_string "" "$txt"; done
 603                 json_select ..
 604         }
 605         json_select ..
 606 }
 607
 608 procd_add_mdns() {
 609         procd_open_data
 610         json_add_object "mdns"
 611         procd_add_mdns_service "$@"
 612         json_close_object
 613         procd_close_data
 614 }
 615
 616 uci_validate_section()
 617 {
 618         local _package="$1"
 619         local _type="$2"
 620         local _name="$3"
 621         local _result
 622         local _error
 623         shift; shift; shift
 624         _result=$(/sbin/validate_data "$_package" "$_type" "$_name" "$@" 2> /dev/null)
 625         _error=$?
 626         eval "$_result"
 627         [ "$_error" = "0" ] || $(/sbin/validate_data "$_package" "$_type" "$_name" "$@" 1> /dev/null)
 628         return $_error
 629 }
 630
 631 uci_load_validate() {
 632         local _package="$1"
 633         local _type="$2"
 634         local _name="$3"
 635         local _function="$4"
 636         local _option
 637         local _result
 638         shift; shift; shift; shift
 639         for _option in "$@"; do
 640                 eval "local ${_option%%:*}"
 641         done
 642         uci_validate_section "$_package" "$_type" "$_name" "$@"
 643         _result=$?
 644         [ -n "$_function" ] || return $_result
 645         eval "$_function \"\$_name\" \"\$_result\""
 646 }
 647
 648 _procd_wrapper \
 649         procd_open_service \
 650         procd_close_service \
 651         procd_add_instance \
 652         procd_add_raw_trigger \
 653         procd_add_config_trigger \
 654         procd_add_interface_trigger \
 655         procd_add_mount_trigger \
 656         procd_add_reload_trigger \
 657         procd_add_reload_interface_trigger \
 658         procd_add_action_mount_trigger \
 659         procd_add_reload_mount_trigger \
 660         procd_add_restart_mount_trigger \
 661         procd_open_trigger \
 662         procd_close_trigger \
 663         procd_open_instance \
 664         procd_close_instance \
 665         procd_open_validate \
 666         procd_close_validate \
 667         procd_add_jail \
 668         procd_add_jail_mount \
 669         procd_add_jail_mount_rw \
 670         procd_set_param \
 671         procd_append_param \
 672         procd_add_validation \
 673         procd_set_config_changed \
 674         procd_kill \
 675         procd_send_signal