src/bash-completion/network

   1 #!/bin/bash
   2 ###############################################################################
   3 #                                                                             #
   4 # IPFire.org - A linux based firewall                                         #
   5 # Copyright (C) 2014 Michael Tremer                                           #
   6 #                                                                             #
   7 # This program is free software: you can redistribute it and/or modify        #
   8 # it under the terms of the GNU General Public License as published by        #
   9 # the Free Software Foundation, either version 3 of the License, or           #
  10 # (at your option) any later version.                                         #
  11 #                                                                             #
  12 # This program is distributed in the hope that it will be useful,             #
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of              #
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               #
  15 # GNU General Public License for more details.                                #
  16 #                                                                             #
  17 # You should have received a copy of the GNU General Public License           #
  18 # along with this program.  If not, see <http://www.gnu.org/licenses/>.       #
  19 #                                                                             #
  20 ###############################################################################
  21 # network(8) completion
  22
  23 _network_find_on_cmdline () {
  24         local word subcommand c=0
  25         while [ ${c} -lt ${cword} ]; do
  26                 word="${words[c]}"
  27                 for subcommand in ${1}; do
  28                         if [ "${subcommand}" = "${word}" ]; then
  29                                 echo "${subcommand}"
  30                                 return
  31                         fi
  32                 done
  33                 ((c++))
  34         done
  35 }
  36
  37 _network_complete_hooks() {
  38         local type="${1}"
  39
  40         COMPREPLY=( $(compgen -W "$(network raw list-hooks "${type}")" -- "${cur}") )
  41 }
  42
  43 _network_complete_ports() {
  44         COMPREPLY=( $(compgen -W "$(network raw list-ports)" -- "${cur}") )
  45 }
  46
  47 _network_complete_zones() {
  48         COMPREPLY=( $(compgen -W "$(network raw list-zones)" -- "${cur}") )
  49 }
  50
  51 _network_color() {
  52         local words=( $@ )
  53
  54         local commands="set reset"
  55         local cmd="$(_network_find_on_cmdline "${commands}")"
  56         if [[ -z "${cmd}" ]]; then
  57                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
  58                 return 0
  59         fi
  60 }
  61
  62 _network_description() {
  63         local words=( $@ )
  64
  65         local commands="edit show"
  66         local cmd="$(_network_find_on_cmdline "${commands}")"
  67         if [[ -z "${cmd}" ]]; then
  68                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
  69                 return 0
  70         fi
  71 }
  72 _network_device() {
  73         local words=( $@ )
  74
  75         local commands="list $(network raw list-devices)"
  76         local cmd="$(_network_find_on_cmdline "${commands}")"
  77         if [[ -z "${cmd}" ]]; then
  78                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
  79                 return 0
  80         fi
  81
  82         local args="${words[@]:1}"
  83         case "${cmd}" in
  84                 list)
  85                         return 0
  86                         ;;
  87                 *)
  88                         _network_device_subcommand ${args}
  89                         ;;
  90         esac
  91 }
  92
  93 _network_device_subcommand() {
  94         local words=( $@ )
  95
  96         local commands="discover identify monitor status unlock ussd"
  97         local cmd="$(_network_find_on_cmdline "${commands}")"
  98         if [[ -z "${cmd}" ]]; then
  99                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 100                 return 0
 101         fi
 102
 103         case "${cmd}" in
 104                 ussd)
 105                         # TODO
 106                         ;;
 107         esac
 108 }
 109
 110 _network_dhcpd() {
 111         local proto="${1}"
 112         shift
 113
 114         local words=( $@ )
 115
 116         local commands="edit reload restart show start stop subnet"
 117         local cmd="$(_network_find_on_cmdline "${commands}")"
 118         if [[ -z "${cmd}" ]]; then
 119                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 120                 return 0
 121         fi
 122
 123         local args="${words[@]:1}"
 124         case "${cmd}" in
 125                 subnet)
 126                         _network_dhcpd_subnet "${proto}" ${args}
 127                         ;;
 128         esac
 129 }
 130
 131 _network_dhcpd_subnet() {
 132         local proto="${1}"
 133         shift
 134
 135         local words=( $@ )
 136
 137         local commands="new remove show $(network raw list-dhcpd-subnets "${proto}")"
 138         local cmd="$(_network_find_on_cmdline "${commands}")"
 139         if [[ -z "${cmd}" ]]; then
 140                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 141                 return 0
 142         fi
 143
 144         local subnet="${words[0]}"
 145         local args="${words[@]:1}"
 146         case "${cmd}" in
 147                 new)
 148                         : # TODO
 149                         ;;
 150                 remove)
 151                         : # TODO
 152                         ;;
 153                 [0-9]*)
 154                         _network_dhcpd_subnet_subcommand "${proto}" "${subnet}" ${args}
 155                         ;;
 156         esac
 157 }
 158
 159 _network_dhcpd_subnet_subcommand() {
 160         local proto="${1}"
 161         local subnet="${2}"
 162         shift 2
 163
 164         local words=( $@ )
 165
 166         local commands="edit options range show"
 167         local cmd="$(_network_find_on_cmdline "${commands}")"
 168         if [[ -z "${cmd}" ]]; then
 169                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 170                 return 0
 171         fi
 172
 173         local args="${words[@]:1}"
 174         case "${cmd}" in
 175                 edit)
 176                         : # TODO
 177                         ;;
 178                 options)
 179                         _network_dhcpd_subnet_subcommand_options "${proto}" "${subnet}" ${args}
 180                         ;;
 181                 range)
 182                         _network_dhcpd_subnet_subcommand_range "${proto}" "${subnet}" ${args}
 183                         ;;
 184         esac
 185 }
 186
 187 _network_dhcpd_subnet_subcommand_options() {
 188         local proto="${1}"
 189         local subnet="${2}"
 190         shift 2
 191
 192         local options option
 193         for option in $(network raw list-dhcpd-subnet-options "${proto}"); do
 194                 options="${options} ${option}="
 195         done
 196
 197         COMPREPLY=( $(compgen -W "${options}" -- "${cur}") )
 198 }
 199
 200 _network_dhcpd_subnet_subcommand_range() {
 201         local proto="${1}"
 202         local subnet="${2}"
 203         shift 2
 204
 205         local words=( $@ )
 206
 207         local commands="new remove"
 208         local cmd="$(_network_find_on_cmdline "${commands}")"
 209         if [[ -z "${cmd}" ]]; then
 210                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 211                 return 0
 212         fi
 213
 214         case "${cmd}" in
 215                 new)
 216                         COMPREPLY=( $(compgen -W "--end= --start=" -- "${cur}") )
 217                         ;;
 218                 remove)
 219                         COMPREPLY=( $(compgen -W "$(network raw list-dhcpd-ranges-of-subnet "${proto}" "${subnet}")" \
 220                                 -- "${cur}") )
 221                         ;;
 222         esac
 223 }
 224
 225 _network_dns_server() {
 226         local words=( $@ )
 227
 228         local commands="add list remove update"
 229         local cmd="$(_network_find_on_cmdline "${commands}")"
 230         if [[ -z "${cmd}" ]]; then
 231                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 232                 return 0
 233         fi
 234
 235         case "${cmd}" in
 236                 remove)
 237                         COMPREPLY=( $(compgen -W "$(network raw list-dns-servers)" \
 238                                 -- "${cur}") )
 239                         ;;
 240         esac
 241 }
 242
 243 _network_port() {
 244         local words=( $@ )
 245
 246         local commands="new destroy $(network raw list-ports)"
 247         local cmd="$(_network_find_on_cmdline "${commands}")"
 248         if [[ -z "${cmd}" ]]; then
 249                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 250                 return 0
 251         fi
 252
 253         local args="${words[@]:1}"
 254         case "${cmd}" in
 255                 new)
 256                         _network_complete_hooks "port"
 257                         ;;
 258                 destroy)
 259                         _network_complete_ports
 260                         ;;
 261                 *)
 262                         local args="${words[@]:1}"
 263                         _network_port_subcommand ${args}
 264                         ;;
 265         esac
 266 }
 267
 268 _network_port_subcommand() {
 269         local words=( $@ )
 270
 271         local commands="color create description down edit identify remove status up"
 272         local cmd="$(_network_find_on_cmdline "${commands}")"
 273         if [[ -z "${cmd}" ]]; then
 274                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 275                 return 0
 276         fi
 277
 278         local args="${words[@]:1}"
 279         case "${cmd}" in
 280                 color)
 281                         _network_color ${args}
 282                         ;;
 283                 description)
 284                         _network_description ${args}
 285                         ;;
 286         esac
 287
 288 }
 289
 290 _network_route() {
 291         local words=( $@ )
 292
 293         local commands="static"
 294         local cmd="$(_network_find_on_cmdline "${commands}")"
 295         if [[ -z "${cmd}" ]]; then
 296                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 297                 return 0
 298         fi
 299
 300         case "${cmd}" in
 301                 static)
 302                         local args="${words[@]}"
 303                         _network_route_static ${args}
 304                         ;;
 305         esac
 306
 307 }
 308
 309 _network_route_static() {
 310         local words=( $@ )
 311
 312         local commands="add list remove reload"
 313         local cmd="$(_network_find_on_cmdline "${commands}")"
 314         if [[ -z "${cmd}" ]]; then
 315                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 316                 return 0
 317         fi
 318
 319         case "${cmd}" in
 320                 add)
 321                         if [[ "${cur}" = -* ]]; then
 322                                 COMPREPLY=( $(compgen -W "--blackhole --gateway= --mtu= \
 323                                         --prohibit --unreachable" -- "${cur}") )
 324                         fi
 325                         ;;
 326                 list)
 327                         # TODO auto-complete options like --protocol here
 328                         COMPREPLY=( $(compgen -W "--protocol=" -- "${cur}") )
 329                         ;;
 330         esac
 331 }
 332
 333 _network_settings() {
 334         local words=( $@ )
 335
 336         local key keys
 337         for key in $(network raw list-settings); do
 338                 keys="${keys} ${key}="
 339         done
 340         COMPREPLY=( $(compgen -W "${keys}" -- "${cur}") )
 341 }
 342
 343 _network_vpn() {
 344         local words=( $@ )
 345
 346         local commands="ipsec security-policies"
 347         local cmd="$(_network_find_on_cmdline "${commands}")"
 348         if [[ -z "${cmd}" ]]; then
 349                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 350                 return 0
 351         fi
 352
 353
 354         local args="${words[@]:1}"
 355         case "${cmd}" in
 356                 ipsec)
 357                         _network_vpn_ipsec ${args}
 358                         ;;
 359                 security-policies)
 360                         _network_vpn_security_policies ${args}
 361                         ;;
 362                 esac
 363 }
 364
 365 _network_vpn_ipsec() {
 366         local words=( $@ )
 367
 368         local commands="connection"
 369         local cmd="$(_network_find_on_cmdline "${commands}")"
 370         if [[ -z "${cmd}" ]]; then
 371                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 372                 return 0
 373         fi
 374
 375
 376         local args="${words[@]:1}"
 377         case "${cmd}" in
 378                 connection)
 379                         _network_vpn_ipsec_connection ${args}
 380                         ;;
 381                 esac
 382 }
 383
 384 _network_vpn_ipsec_connection() {
 385         local words=( $@ )
 386
 387         local commands="destroy new $(network raw list-ipsec-connections)"
 388         local cmd="$(_network_find_on_cmdline "${commands}")"
 389         if [[ -z "${cmd}" ]]; then
 390                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 391                 return 0
 392         fi
 393
 394
 395         local args="${words[@]:1}"
 396         case "${cmd}" in
 397                 destroy)
 398                         :
 399                         ;;
 400                 new)
 401                         :
 402                         ;;
 403                 *)
 404                         if network raw ipsec-connection-exists ${cmd}; then
 405                                 _network_vpn_ipsec_connection_subcommands ${cmd} ${args}
 406                         fi
 407                         ;;
 408                 esac
 409 }
 410
 411 _network_vpn_ipsec_connection_subcommands() {
 412         local connection=${1}
 413         shift
 414         local words=( $@ )
 415
 416         local commands="authentication down inactivity-timeout local mode peer remote security-policy show up"
 417         local cmd="$(_network_find_on_cmdline "${commands}")"
 418         if [[ -z "${cmd}" ]]; then
 419                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 420                 return 0
 421         fi
 422
 423
 424         local args="${words[@]:1}"
 425         case "${cmd}" in
 426                 authentication)
 427                         _network_vpn_ipsec_connection_subcommands_authentication ${connection} ${args}
 428                         ;;
 429                 local)
 430                         _network_vpn_ipsec_connection_subcommands_local_remote ${connection} "local" ${args}
 431                         ;;
 432                 mode)
 433                         _network_vpn_ipsec_connection_subcommands_mode ${args}
 434                         ;;
 435                 remote)
 436                         _network_vpn_ipsec_connection_subcommands_local_remote ${connection} "remote" ${args}
 437                         ;;
 438                 security-policy)
 439                         _network_vpn_ipsec_connection_subcommands_security_policy ${args}
 440                         ;;
 441                 esac
 442 }
 443
 444 _network_vpn_ipsec_connection_subcommands_authentication() {
 445         local connection=${1}
 446         shift
 447         local words=( $@ )
 448
 449         local commands="psk mode"
 450         local cmd="$(_network_find_on_cmdline "${commands}")"
 451         if [[ -z "${cmd}" ]]; then
 452                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 453                 return 0
 454         fi
 455
 456
 457         local args="${words[@]:1}"
 458         case "${cmd}" in
 459                 mode)
 460                         _network_vpn_ipsec_connection_subcommands_authentication_mode ${connection} ${args}
 461                         ;;
 462                         esac
 463 }
 464
 465 _network_vpn_ipsec_connection_subcommands_local_remote() {
 466         local connection=${1}
 467         local type=${2}
 468         shift 2
 469         local words=( $@ )
 470
 471         local commands="id prefix"
 472         local cmd="$(_network_find_on_cmdline "${commands}")"
 473         if [[ -z "${cmd}" ]]; then
 474                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 475                 return 0
 476         fi
 477
 478
 479         local args="${words[@]:1}"
 480         case "${cmd}" in
 481                 prefix)
 482                         _network_vpn_ipsec_connection_subcommands_prefix "${connection}" "${type}" ${args}
 483                         ;;
 484                         esac
 485 }
 486
 487 _network_vpn_ipsec_connection_subcommands_prefix() {
 488         :
 489 }
 490
 491 _network_vpn_ipsec_connection_subcommands_authentication_mode() {
 492         local connection=${1}
 493         shift
 494         local words=( $@ )
 495
 496         local commands="PSK"
 497         local cmd="$(_network_find_on_cmdline "${commands}")"
 498         if [[ -z "${cmd}" ]]; then
 499                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 500                 return 0
 501         fi
 502 }
 503
 504 _network_vpn_ipsec_connection_subcommands_mode() {
 505         local words=( $@ )
 506
 507         local commands="gre-transport tunnel vti"
 508         local cmd="$(_network_find_on_cmdline "${commands}")"
 509         if [[ -z "${cmd}" ]]; then
 510                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 511                 return 0
 512         fi
 513 }
 514
 515 _network_vpn_ipsec_connection_subcommands_security_policy() {
 516         local words=( $@ )
 517
 518         local commands="$(network raw list-vpn-security-policies-all)"
 519         local cmd="$(_network_find_on_cmdline "${commands}")"
 520         if [[ -z "${cmd}" ]]; then
 521                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 522                 return 0
 523         fi
 524 }
 525
 526 _network_vpn_security_policies() {
 527         local words=( $@ )
 528
 529         local commands="destroy new $(network raw list-vpn-security-policies-all)"
 530         local cmd="$(_network_find_on_cmdline "${commands}")"
 531         if [[ -z "${cmd}" ]]; then
 532                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 533                 return 0
 534         fi
 535
 536
 537         local args="${words[@]:1}"
 538         case "${cmd}" in
 539                 destroy)
 540                         :
 541                         ;;
 542                 new)
 543                         :
 544                         ;;
 545                 *)
 546                         if network raw vpn-security-policy-exists ${cmd}; then
 547                                 _network_vpn_security_policies_subcommands ${cmd} ${args}
 548                         fi
 549                         ;;
 550                 esac
 551 }
 552
 553 _network_vpn_security_policies_subcommands() {
 554         local policy=${1}
 555         shift
 556         local words=( $@ )
 557
 558         local commands="cipher compression group-type integrity key-exchange lifetime pfs show"
 559         local cmd="$(_network_find_on_cmdline "${commands}")"
 560         if [[ -z "${cmd}" ]]; then
 561                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 562                 return 0
 563         fi
 564
 565
 566         local args="${words[@]:1}"
 567         case "${cmd}" in
 568                 cipher)
 569                         _network_vpn_security_policies_subcommands_cipher ${policy} ${args}
 570                         ;;
 571                 compression)
 572                         _network_vpn_security_policies_subcommands_compression ${policy} ${args}
 573                         ;;
 574                 group-type)
 575                         _network_vpn_security_policies_subcommands_group_type ${policy} ${args}
 576                         ;;
 577                 integrity)
 578                         _network_vpn_security_policies_subcommands_integrity ${policy} ${args}
 579                         ;;
 580                 key-exchange)
 581                         _network_vpn_security_policies_subcommands_key_exchange ${policy} ${args}
 582                         ;;
 583                 pfs)
 584                         _network_vpn_security_policies_subcommands_pfs ${policy} ${args}
 585                         ;;
 586                 esac
 587 }
 588
 589 _network_vpn_security_policies_subcommands_cipher() {
 590         :
 591 }
 592
 593 _network_vpn_security_policies_subcommands_compression() {
 594         :
 595 }
 596
 597 _network_vpn_security_policies_subcommands_group_type() {
 598         :
 599 }
 600
 601 _network_vpn_security_policies_subcommands_integrity() {
 602         :
 603 }
 604
 605 _network_vpn_security_policies_subcommands_key_exchange() {
 606         :
 607 }
 608
 609 _network_vpn_security_policies_subcommands_pfs() {
 610         :
 611 }
 612
 613 _network_zone() {
 614         local words=( $@ )
 615
 616         local commands="new destroy $(network raw list-zones)"
 617         local cmd="$(_network_find_on_cmdline "${commands}")"
 618         if [[ -z "${cmd}" ]]; then
 619                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 620                 return 0
 621         fi
 622
 623
 624         local args="${words[@]:1}"
 625         case "${cmd}" in
 626                 new)
 627                         _network_zone_new ${args}
 628                         ;;
 629                 destroy)
 630                         _network_complete_zones
 631                         ;;
 632                 *)
 633                         local zone="${cmd}"
 634                         local args="${words[@]:1}"
 635                         _network_zone_subcommand "${zone}" ${args}
 636                         ;;
 637         esac
 638 }
 639
 640 _network_zone_new() {
 641         local words=( $@ )
 642         local cmd=${words[@]:0:1}
 643
 644         # Suggest useful zone names
 645         if [[ -z "${cmd}" ]]; then
 646                 local commands="$(network raw list-next-free-zones)"
 647                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 648
 649         # If a valid zone name was entered, we can move on
 650         elif network raw zone-name-is-valid ${cmd}; then
 651                 local args="${words[@]:1}"
 652                 _network_complete_hooks zone ${args}
 653         fi
 654
 655         return 0
 656 }
 657
 658 _network_zone_subcommand() {
 659         local zone="${1}"
 660         shift
 661
 662         local words=( $@ )
 663
 664         local commands="color config description disable down edit enable identify port rename status up"
 665         local cmd="$(_network_find_on_cmdline "${commands}")"
 666         if [[ -z "${cmd}" ]]; then
 667                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 668                 return 0
 669         fi
 670
 671         local args="${words[@]:1}"
 672         case "${cmd}" in
 673                 config)
 674                         _network_zone_subcommand_config "${zone}" ${args}
 675                         ;;
 676                 port)
 677                         _network_zone_subcommand_port "${zone}" ${args}
 678                         ;;
 679                 color)
 680                         _network_color ${args}
 681                         ;;
 682                 description)
 683                         _network_description ${args}
 684                         ;;
 685         esac
 686 }
 687
 688 _network_zone_subcommand_config() {
 689         local zone="${1}"
 690         shift
 691
 692         local words=( $@ )
 693
 694         local commands="destroy list new $(network raw list-zone-config-hids ${zone})"
 695
 696         local cmd="$(_network_find_on_cmdline "${commands}")"
 697         if [[ -z "${cmd}" ]]; then
 698                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 699                 return 0
 700         fi
 701
 702         local args="${words[@]:1}"
 703         case "${cmd}" in
 704                 new)
 705                         _network_complete_hooks "config"
 706                         ;;
 707                 destroy)
 708                         _network_zone_subcommand_config_destroy ${zone} ${args}
 709                         ;;
 710                 *)
 711                         if network raw zone-config-id-is-valid ${zone} ${cmd} || network raw zone-config-hid-is-valid ${zone} ${cmd}; then
 712                                 _network_zone_subcommand_config_subcommand ${zone} ${args}
 713                         fi
 714                         ;;
 715         esac
 716 }
 717
 718 _network_zone_subcommand_config_subcommand() {
 719         local zone="${1}"
 720         shift
 721
 722         local words=( $@ )
 723
 724         local commands="edit"
 725
 726         local cmd="$(_network_find_on_cmdline "${commands}")"
 727         if [[ -z "${cmd}" ]]; then
 728                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 729                 return 0
 730         fi
 731 }
 732
 733 _network_zone_subcommand_config_destroy() {
 734         local zone="${1}"
 735         shift
 736
 737         local words=( $@ )
 738
 739         local commands="$(network raw list-zone-config-ids ${zone})"
 740
 741         local cmd="$(_network_find_on_cmdline "${commands}")"
 742         if [[ -z "${cmd}" ]]; then
 743                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 744                 return 0
 745         fi
 746 }
 747
 748 _network_zone_subcommand_port() {
 749         local zone="${1}"
 750         shift
 751
 752         local words=( $@ )
 753
 754         local commands="attach detach $(network raw list-ports-of-zone "${zone}")"
 755         local cmd="$(_network_find_on_cmdline "${commands}")"
 756         if [[ -z "${cmd}" ]]; then
 757                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 758                 return 0
 759         fi
 760
 761         case "${cmd}" in
 762                 attach)
 763                         COMPREPLY=( $(compgen -W "$(network raw list-free-ports "${zone}")" \
 764                                 -- "${cur}") )
 765                         ;;
 766                 detach)
 767                         COMPREPLY=( $(compgen -W "$(network raw list-ports-of-zone "${zone}")" \
 768                                 -- "${cur}") )
 769                         ;;
 770                 *)
 771                         local port="${cmd}"
 772                         local args="${words[@]:1}"
 773                         _network_zone_subcommand_port_subcommand "${zone}" "${port}" ${args}
 774                         ;;
 775         esac
 776 }
 777
 778 _network_zone_subcommand_port_subcommand() {
 779         local zone="${1}"
 780         local port="${2}"
 781         shift 2
 782
 783         local words=( $@ )
 784
 785         local commands="edit"
 786         local cmd="$(_network_find_on_cmdline "${commands}")"
 787         if [[ -z "${cmd}" ]]; then
 788                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 789                 return 0
 790         fi
 791
 792         case "${cmd}" in
 793                 edit)
 794                         # TODO auto-complete the zone-port hook
 795                         ;;
 796         esac
 797 }
 798
 799 _network() {
 800         local cur prev words cword
 801         _init_completion || return
 802
 803         local cmd i
 804         for (( i=1; i < ${#words[@]} - 1; i++ )); do
 805                 [[ "${words[i]}" = -* ]] && continue
 806                 cmd="${words[i]}" && break
 807         done
 808
 809         if [[ -z "${cmd}" ]]; then
 810                 case "${cur}" in
 811                         -*)
 812                                 COMPREPLY=( $(compgen -W "--debug" -- "${cur}") )
 813                                 ;;
 814                         *)
 815                                 COMPREPLY=( $(compgen -W "device dhcpv4 dhcpv6 dns-server \
 816                                         help hostname port reset route settings status vpn zone" \
 817                                         -- "${cur}") )
 818                                 ;;
 819                 esac
 820
 821                 return 0
 822         fi
 823
 824         local args="${words[@]:i+1}"
 825         case "${cmd}" in
 826                 device)
 827                         _network_device ${args}
 828                         ;;
 829                 dhcpv[64])
 830                         _network_dhcpd "${cmd/dhcpv/ipv}" ${args}
 831                         ;;
 832                 dns-server)
 833                         _network_dns_server ${args}
 834                         ;;
 835                 port)
 836                         _network_port ${args}
 837                         ;;
 838                 route)
 839                         _network_route ${args}
 840                         ;;
 841                 settings)
 842                         _network_settings ${args}
 843                         ;;
 844                 start|stop|status)
 845                         # start, stop and status optionally take a zone
 846                         _network_complete_zones
 847                         ;;
 848                 vpn)
 849                         _network_vpn ${args}
 850                         ;;
 851                 zone)
 852                         _network_zone ${args}
 853                         ;;
 854         esac
 855 } && complete -F _network network