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 color description 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                 color)
 430                         _network_color ${args}
 431                         ;;
 432                 description)
 433                         _network_description ${args}
 434                         ;;
 435                 local)
 436                         _network_vpn_ipsec_connection_subcommands_local_remote ${connection} "local" ${args}
 437                         ;;
 438                 mode)
 439                         _network_vpn_ipsec_connection_subcommands_mode ${args}
 440                         ;;
 441                 remote)
 442                         _network_vpn_ipsec_connection_subcommands_local_remote ${connection} "remote" ${args}
 443                         ;;
 444                 security-policy)
 445                         _network_vpn_ipsec_connection_subcommands_security_policy ${args}
 446                         ;;
 447                 esac
 448 }
 449
 450 _network_vpn_ipsec_connection_subcommands_authentication() {
 451         local connection=${1}
 452         shift
 453         local words=( $@ )
 454
 455         local commands="mode pre-shared-key"
 456         local cmd="$(_network_find_on_cmdline "${commands}")"
 457         if [[ -z "${cmd}" ]]; then
 458                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 459                 return 0
 460         fi
 461
 462
 463         local args="${words[@]:1}"
 464         case "${cmd}" in
 465                 mode)
 466                         _network_vpn_ipsec_connection_subcommands_authentication_mode ${connection} ${args}
 467                         ;;
 468                         esac
 469 }
 470
 471 _network_vpn_ipsec_connection_subcommands_local_remote() {
 472         local connection=${1}
 473         local type=${2}
 474         shift 2
 475         local words=( $@ )
 476
 477         local commands="id prefix"
 478         local cmd="$(_network_find_on_cmdline "${commands}")"
 479         if [[ -z "${cmd}" ]]; then
 480                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 481                 return 0
 482         fi
 483
 484
 485         local args="${words[@]:1}"
 486         case "${cmd}" in
 487                 prefix)
 488                         _network_vpn_ipsec_connection_subcommands_prefix "${connection}" "${type}" ${args}
 489                         ;;
 490                         esac
 491 }
 492
 493 _network_vpn_ipsec_connection_subcommands_prefix() {
 494         :
 495 }
 496
 497 _network_vpn_ipsec_connection_subcommands_authentication_mode() {
 498         local connection=${1}
 499         shift
 500         local words=( $@ )
 501
 502         local commands="PSK"
 503         local cmd="$(_network_find_on_cmdline "${commands}")"
 504         if [[ -z "${cmd}" ]]; then
 505                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 506                 return 0
 507         fi
 508 }
 509
 510 _network_vpn_ipsec_connection_subcommands_mode() {
 511         local words=( $@ )
 512
 513         local commands="gre-transport tunnel vti"
 514         local cmd="$(_network_find_on_cmdline "${commands}")"
 515         if [[ -z "${cmd}" ]]; then
 516                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 517                 return 0
 518         fi
 519 }
 520
 521 _network_vpn_ipsec_connection_subcommands_security_policy() {
 522         local words=( $@ )
 523
 524         local commands="$(network raw list-vpn-security-policies-all)"
 525         local cmd="$(_network_find_on_cmdline "${commands}")"
 526         if [[ -z "${cmd}" ]]; then
 527                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 528                 return 0
 529         fi
 530 }
 531
 532 _network_vpn_security_policies() {
 533         local words=( $@ )
 534
 535         local commands="destroy new $(network raw list-vpn-security-policies-all)"
 536         local cmd="$(_network_find_on_cmdline "${commands}")"
 537         if [[ -z "${cmd}" ]]; then
 538                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 539                 return 0
 540         fi
 541
 542
 543         local args="${words[@]:1}"
 544         case "${cmd}" in
 545                 destroy)
 546                         :
 547                         ;;
 548                 new)
 549                         :
 550                         ;;
 551                 *)
 552                         if network raw vpn-security-policy-exists ${cmd}; then
 553                                 _network_vpn_security_policies_subcommands ${cmd} ${args}
 554                         fi
 555                         ;;
 556                 esac
 557 }
 558
 559 _network_vpn_security_policies_subcommands() {
 560         local policy=${1}
 561         shift
 562         local words=( $@ )
 563
 564         local commands="ciphers compression group-types integrities key-exchange lifetime pfs pseudo-random-functions show"
 565         local cmd="$(_network_find_on_cmdline "${commands}")"
 566         if [[ -z "${cmd}" ]]; then
 567                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 568                 return 0
 569         fi
 570
 571
 572         local args="${words[@]:1}"
 573         case "${cmd}" in
 574                 ciphers)
 575                         _network_vpn_security_policies_subcommands_ciphers ${policy} ${args}
 576                         ;;
 577                 compression)
 578                         _network_vpn_security_policies_subcommands_compression ${policy} ${args}
 579                         ;;
 580                 group-types)
 581                         _network_vpn_security_policies_subcommands_group_types ${policy} ${args}
 582                         ;;
 583                 integrities)
 584                         _network_vpn_security_policies_subcommands_integrities ${policy} ${args}
 585                         ;;
 586                 pseudo-random-functions)
 587                         _network_vpn_security_policies_subcommands_pseudo_random_functions ${policy} ${args}
 588                         ;;
 589                 key-exchange)
 590                         _network_vpn_security_policies_subcommands_key_exchange ${policy} ${args}
 591                         ;;
 592                 pfs)
 593                         _network_vpn_security_policies_subcommands_pfs ${policy} ${args}
 594                         ;;
 595                 esac
 596 }
 597
 598 _network_vpn_security_policies_subcommands_ciphers() {
 599         :
 600 }
 601
 602 _network_vpn_security_policies_subcommands_compression() {
 603         :
 604 }
 605
 606 _network_vpn_security_policies_subcommands_group_types() {
 607         :
 608 }
 609
 610 _network_vpn_security_policies_subcommands_integrities() {
 611         :
 612 }
 613
 614 _network_vpn_security_policies_subcommands_pseudo_random_functions() {
 615         :
 616 }
 617
 618 _network_vpn_security_policies_subcommands_key_exchange() {
 619         :
 620 }
 621
 622 _network_vpn_security_policies_subcommands_pfs() {
 623         :
 624 }
 625
 626 _network_zone() {
 627         local words=( $@ )
 628
 629         local commands="new destroy $(network raw list-zones)"
 630         local cmd="$(_network_find_on_cmdline "${commands}")"
 631         if [[ -z "${cmd}" ]]; then
 632                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 633                 return 0
 634         fi
 635
 636
 637         local args="${words[@]:1}"
 638         case "${cmd}" in
 639                 new)
 640                         _network_zone_new ${args}
 641                         ;;
 642                 destroy)
 643                         _network_complete_zones
 644                         ;;
 645                 *)
 646                         local zone="${cmd}"
 647                         local args="${words[@]:1}"
 648                         _network_zone_subcommand "${zone}" ${args}
 649                         ;;
 650         esac
 651 }
 652
 653 _network_zone_new() {
 654         local words=( $@ )
 655         local cmd=${words[@]:0:1}
 656
 657         # Suggest useful zone names
 658         if [[ -z "${cmd}" ]]; then
 659                 local commands="$(network raw list-next-free-zones)"
 660                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 661
 662         # If a valid zone name was entered, we can move on
 663         elif network raw zone-name-is-valid ${cmd}; then
 664                 local args="${words[@]:1}"
 665                 _network_complete_hooks zone ${args}
 666         fi
 667
 668         return 0
 669 }
 670
 671 _network_zone_subcommand() {
 672         local zone="${1}"
 673         shift
 674
 675         local words=( $@ )
 676
 677         local commands="color config description disable down edit enable identify port rename status up"
 678         local cmd="$(_network_find_on_cmdline "${commands}")"
 679         if [[ -z "${cmd}" ]]; then
 680                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 681                 return 0
 682         fi
 683
 684         local args="${words[@]:1}"
 685         case "${cmd}" in
 686                 config)
 687                         _network_zone_subcommand_config "${zone}" ${args}
 688                         ;;
 689                 port)
 690                         _network_zone_subcommand_port "${zone}" ${args}
 691                         ;;
 692                 color)
 693                         _network_color ${args}
 694                         ;;
 695                 description)
 696                         _network_description ${args}
 697                         ;;
 698         esac
 699 }
 700
 701 _network_zone_subcommand_config() {
 702         local zone="${1}"
 703         shift
 704
 705         local words=( $@ )
 706
 707         local commands="destroy list new $(network raw list-zone-config-hids ${zone})"
 708
 709         local cmd="$(_network_find_on_cmdline "${commands}")"
 710         if [[ -z "${cmd}" ]]; then
 711                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 712                 return 0
 713         fi
 714
 715         local args="${words[@]:1}"
 716         case "${cmd}" in
 717                 new)
 718                         _network_complete_hooks "config"
 719                         ;;
 720                 destroy)
 721                         _network_zone_subcommand_config_destroy ${zone} ${args}
 722                         ;;
 723                 *)
 724                         if network raw zone-config-id-is-valid ${zone} ${cmd} || network raw zone-config-hid-is-valid ${zone} ${cmd}; then
 725                                 _network_zone_subcommand_config_subcommand ${zone} ${args}
 726                         fi
 727                         ;;
 728         esac
 729 }
 730
 731 _network_zone_subcommand_config_subcommand() {
 732         local zone="${1}"
 733         shift
 734
 735         local words=( $@ )
 736
 737         local commands="edit"
 738
 739         local cmd="$(_network_find_on_cmdline "${commands}")"
 740         if [[ -z "${cmd}" ]]; then
 741                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 742                 return 0
 743         fi
 744 }
 745
 746 _network_zone_subcommand_config_destroy() {
 747         local zone="${1}"
 748         shift
 749
 750         local words=( $@ )
 751
 752         local commands="$(network raw list-zone-config-ids ${zone})"
 753
 754         local cmd="$(_network_find_on_cmdline "${commands}")"
 755         if [[ -z "${cmd}" ]]; then
 756                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 757                 return 0
 758         fi
 759 }
 760
 761 _network_zone_subcommand_port() {
 762         local zone="${1}"
 763         shift
 764
 765         local words=( $@ )
 766
 767         local commands="attach detach $(network raw list-ports-of-zone "${zone}")"
 768         local cmd="$(_network_find_on_cmdline "${commands}")"
 769         if [[ -z "${cmd}" ]]; then
 770                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 771                 return 0
 772         fi
 773
 774         case "${cmd}" in
 775                 attach)
 776                         COMPREPLY=( $(compgen -W "$(network raw list-free-ports "${zone}")" \
 777                                 -- "${cur}") )
 778                         ;;
 779                 detach)
 780                         COMPREPLY=( $(compgen -W "$(network raw list-ports-of-zone "${zone}")" \
 781                                 -- "${cur}") )
 782                         ;;
 783                 *)
 784                         local port="${cmd}"
 785                         local args="${words[@]:1}"
 786                         _network_zone_subcommand_port_subcommand "${zone}" "${port}" ${args}
 787                         ;;
 788         esac
 789 }
 790
 791 _network_zone_subcommand_port_subcommand() {
 792         local zone="${1}"
 793         local port="${2}"
 794         shift 2
 795
 796         local words=( $@ )
 797
 798         local commands="edit"
 799         local cmd="$(_network_find_on_cmdline "${commands}")"
 800         if [[ -z "${cmd}" ]]; then
 801                 COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
 802                 return 0
 803         fi
 804
 805         case "${cmd}" in
 806                 edit)
 807                         # TODO auto-complete the zone-port hook
 808                         ;;
 809         esac
 810 }
 811
 812 _network() {
 813         local cur prev words cword
 814         _init_completion || return
 815
 816         local cmd i
 817         for (( i=1; i < ${#words[@]} - 1; i++ )); do
 818                 [[ "${words[i]}" = -* ]] && continue
 819                 cmd="${words[i]}" && break
 820         done
 821
 822         if [[ -z "${cmd}" ]]; then
 823                 case "${cur}" in
 824                         -*)
 825                                 COMPREPLY=( $(compgen -W "--debug" -- "${cur}") )
 826                                 ;;
 827                         *)
 828                                 COMPREPLY=( $(compgen -W "device dhcpv4 dhcpv6 dns-server \
 829                                         help hostname port reset route settings status vpn zone" \
 830                                         -- "${cur}") )
 831                                 ;;
 832                 esac
 833
 834                 return 0
 835         fi
 836
 837         local args="${words[@]:i+1}"
 838         case "${cmd}" in
 839                 device)
 840                         _network_device ${args}
 841                         ;;
 842                 dhcpv[64])
 843                         _network_dhcpd "${cmd/dhcpv/ipv}" ${args}
 844                         ;;
 845                 dns-server)
 846                         _network_dns_server ${args}
 847                         ;;
 848                 port)
 849                         _network_port ${args}
 850                         ;;
 851                 route)
 852                         _network_route ${args}
 853                         ;;
 854                 settings)
 855                         _network_settings ${args}
 856                         ;;
 857                 start|stop|status)
 858                         # start, stop and status optionally take a zone
 859                         _network_complete_zones
 860                         ;;
 861                 vpn)
 862                         _network_vpn ${args}
 863                         ;;
 864                 zone)
 865                         _network_zone ${args}
 866                         ;;
 867         esac
 868 } && complete -F _network network