src/network

   1 #!/bin/bash
   2 ###############################################################################
   3 #                                                                             #
   4 # IPFire.org - A linux based firewall                                         #
   5 # Copyright (C) 2010  Michael Tremer & Christian Schmidt                      #
   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
  22 # Parse the command line
  23 while [ $# -gt 0 ]; do
  24         case "${1}" in
  25                 -d|--debug)
  26                         DEBUG=1
  27                         ;;
  28                 *)
  29                         action=${1}
  30                         ;;
  31         esac
  32         shift
  33         [ -n "${action}" ] && break
  34 done
  35
  36 . /usr/lib/network/functions
  37
  38 # Read network settings
  39 network_settings_read
  40
  41 cli_settings() {
  42         if cli_help_requested $@; then
  43                 cli_show_man network-settings
  44                 exit ${EXIT_OK}
  45         fi
  46
  47         if [ -n "${1}" ]; then
  48                 network_settings_set $@
  49                 network_settings_write
  50         else
  51                 network_settings_print
  52         fi
  53 }
  54
  55 cli_device() {
  56         if cli_help_requested $@; then
  57                 cli_show_man network-device
  58                 exit ${EXIT_OK}
  59         fi
  60
  61         local action="${1}"
  62         shift
  63
  64         case "${action}" in
  65                 list)
  66                         cli_device_list $@
  67                         ;;
  68                 *)
  69                         local device="${action}"
  70                         action="${1}"
  71                         shift
  72
  73                         if ! isset device; then
  74                                 cli_show_man network-device
  75                                 return ${EXIT_ERROR}
  76                         fi
  77
  78                         assert device_exists ${device}
  79
  80                         case "${action}" in
  81                                 discover)
  82                                         cli_device_discover ${device} $@
  83                                         ;;
  84                                 identify)
  85                                         device_identify "${device}" $@
  86                                         ;;
  87                                 monitor)
  88                                         cli_device_monitor "${device}" $@
  89                                         ;;
  90                                 status)
  91                                         cli_device_status ${device}
  92                                         ;;
  93                                 unlock)
  94                                         cli_device_serial_unlock ${device} $@
  95                                         ;;
  96                                 ussd)
  97                                         cli_device_send_ussd_command "${device}" $@
  98                                         ;;
  99                                 *)
 100                                         cli_show_man network-device
 101                                         ;;
 102                         esac
 103                         ;;
 104         esac
 105
 106         return ${EXIT_OK}
 107 }
 108
 109 cli_device_status() {
 110         local device="${1}"
 111         assert isset device
 112
 113         # Disable debugging output here.
 114         local log_disable_stdout=${LOG_DISABLE_STDOUT}
 115         LOG_DISABLE_STDOUT="true"
 116
 117         # Save the type of the device for later.
 118         local type=$(device_get_type ${device})
 119
 120         cli_headline 1 "Device status: ${device}"
 121         cli_print_fmt1 1 "Name"         "${device}"
 122
 123         # Handle special devices
 124         case "${type}" in
 125                 phy)
 126                         cli_device_status_phy "${device}"
 127                         return $?
 128                         ;;
 129                 serial)
 130                         cli_device_status_serial "${device}"
 131                         return $?
 132                         ;;
 133         esac
 134
 135         # Print the device status.
 136         device_is_up ${device} &>/dev/null
 137         local status=$?
 138
 139         case "${status}" in
 140                 ${EXIT_TRUE})
 141                         status="${CLR_GREEN_B}UP${CLR_RESET}"
 142                         ;;
 143                 ${EXIT_FALSE})
 144                         status="${CLR_RED_B}DOWN${CLR_RESET}"
 145                         ;;
 146         esac
 147
 148         cli_print_fmt1 1 "Status"       "${status}"
 149         cli_print_fmt1 1 "Type"         "${type}"
 150
 151         # Ethernet-compatible?
 152         device_is_ethernet_compatible "${device}" &>/dev/null
 153         cli_print_fmt1 1 "Ethernet-compatible" "$(cli_print_bool $?)"
 154
 155         cli_print_fmt1 1 "Address"      "$(device_get_address ${device})"
 156         cli_space
 157
 158         # Print the link speed for ethernet devices.
 159         if device_is_up ${device} &>/dev/null; then
 160                 local link="$(device_get_link_string "${device}")"
 161                 if isset link; then
 162                         cli_print_fmt1 1 "Link" "${link}"
 163                 fi
 164         fi
 165
 166         cli_print_fmt1 1 "MTU"          "$(device_get_mtu ${device})"
 167         cli_space
 168
 169         # Print device statistics.
 170         cli_device_stats 2 ${device}
 171
 172         # Print some more information.
 173         device_has_carrier ${device} &>/dev/null
 174         cli_print_fmt1 1 "Has carrier?" "$(cli_print_bool $?)"
 175
 176         device_is_promisc ${device} &>/dev/null
 177         cli_print_fmt1 1 "Promisc"      "$(cli_print_bool $?)"
 178
 179         # Supports multiqueue?
 180         if device_supports_multiqueue ${device}; then
 181                 cli_print_fmt 1 "Multiqueue" "Supported"
 182         fi
 183         cli_space
 184
 185         cli_device_show_queues 2 ${device}
 186
 187         # Print all vlan devices.
 188         local vlans=$(device_get_vlans ${device})
 189         if [ -n "${vlans}" ]; then
 190                 cli_headline 2 "VLAN devices"
 191
 192                 local vlan
 193                 for vlan in ${vlans}; do
 194                         cli_print 2 "* %-6s - %s" "${vlan}" "$(device_get_address ${vlan})"
 195                 done
 196                 cli_space
 197         fi
 198
 199         case "${type}" in
 200                 wireless*)
 201                         local phy="$(device_get_phy "${device}")"
 202                         if isset phy; then
 203                                 cli_headline 2 "PHY"
 204                                 cli_print_fmt1 2 "Name" "${phy}"
 205                                 cli_print_fmt1 2 "Address" "$(phy_get_address "${phy}")"
 206                                 cli_space
 207                         fi
 208                         ;;
 209         esac
 210
 211         # Reset the logging level.
 212         LOG_DISABLE_STDOUT=${log_disable_stdout}
 213 }
 214
 215 cli_device_status_serial() {
 216         local device=${1}
 217         assert device_is_serial ${device}
 218
 219         serial_is_locked ${device} &>/dev/null
 220         local locked=$?
 221
 222         cli_print_fmt1 1 "Locked" "$(cli_print_bool ${locked})"
 223         cli_space
 224
 225         # Cannot go on when the device is locked.
 226         [ ${locked} -eq ${EXIT_TRUE} ] && return ${EXIT_OK}
 227
 228         cli_print_fmt1 1 "Manufacturer" \
 229                 "$(modem_get_manufacturer ${device})"
 230         cli_print_fmt1 1 "Model" \
 231                 "$(modem_get_model ${device})"
 232         cli_print_fmt1 1 "Software version" \
 233                 "$(modem_get_software_version ${device})"
 234
 235         # Mobile
 236         if modem_is_mobile "${device}"; then
 237                 cli_print_fmt1 1 "IMEI" \
 238                         "$(modem_get_device_imei ${device})"
 239         fi
 240         cli_space
 241
 242         if modem_is_mobile "${device}"; then
 243                 modem_mobile_network_status "${device}" 2
 244                 cli_space
 245         fi
 246 }
 247
 248 cli_device_status_phy() {
 249         local phy="${1}"
 250         assert phy_exists "${phy}"
 251
 252         local address="$(phy_get_address "${phy}")"
 253         cli_print_fmt1 1 "Address" "${address}"
 254         cli_space
 255
 256         local devices="$(phy_get_devices "${phy}")"
 257         if isset devices; then
 258                 cli_headline 2 "Soft interfaces"
 259
 260                 local device
 261                 for device in ${devices}; do
 262                         cli_print 2 "* %s" "${device}"
 263                 done
 264                 cli_space
 265         fi
 266
 267         return ${EXIT_OK}
 268 }
 269
 270 cli_device_discover() {
 271         local device=${1}
 272         shift
 273
 274         # This can only be executed for ethernet (or compatible) devices
 275         if ! device_is_ethernet_compatible "${device}"; then
 276                 return ${EXIT_OK}
 277         fi
 278
 279         local raw
 280
 281         while [ $# -gt 0 ]; do
 282                 case "${1}" in
 283                         --raw)
 284                                 raw=1
 285                                 ;;
 286                 esac
 287                 shift
 288         done
 289
 290         local up
 291         device_is_up ${device} && up=1
 292         device_set_up ${device}
 293
 294         enabled raw || echo "${device}"
 295
 296         local hook
 297         local out
 298         local ret
 299         for hook in $(hook_zone_get_all); do
 300                 out=$(hook_zone_exec ${hook} discover ${device})
 301                 ret=$?
 302
 303                 [ ${ret} -eq ${DISCOVER_NOT_SUPPORTED} ] && continue
 304
 305                 if enabled raw; then
 306                         case "${ret}" in
 307                                 ${DISCOVER_OK})
 308                                         echo "${hook}: OK"
 309                                         local line
 310                                         while read line; do
 311                                                 echo "${hook}: ${line}"
 312                                         done <<<"${out}"
 313                                         ;;
 314
 315                                 ${DISCOVER_ERROR})
 316                                         echo "${hook}: FAILED"
 317                                         ;;
 318                         esac
 319                 else
 320                         case "${ret}" in
 321                                 ${DISCOVER_OK})
 322                                         echo "  ${hook} was successful."
 323                                         local line
 324                                         while read line; do
 325                                                 echo "  ${line}"
 326                                         done <<<"${out}"
 327                                         ;;
 328
 329                                 ${DISCOVER_ERROR})
 330                                         echo "  ${hook} failed."
 331                                         ;;
 332                         esac
 333                 fi
 334         done
 335
 336         echo # New line
 337
 338         [ "${up}" = "1" ] || device_set_down ${device}
 339 }
 340
 341 cli_device_serial_unlock() {
 342         if cli_help_requested $@; then
 343                 cli_show_man network-device
 344                 exit ${EXIT_OK}
 345         fi
 346
 347         local device=${1}
 348         assert isset device
 349
 350         if ! device_is_serial ${device}; then
 351                 error "${device} is not a serial device."
 352                 error "Unlocking is only supported for serial devices."
 353                 exit ${EXIT_ERROR}
 354         fi
 355
 356         # Read the current state of the SIM card.
 357         modem_sim_status ${device} &>/dev/null
 358         local sim_status_code=$?
 359
 360         # If the SIM card is already unlocked, we don't need to do anything.
 361         if [ ${sim_status_code} -eq ${EXIT_SIM_READY} ]; then
 362                 print "The SIM card is already unlocked."
 363                 exit ${EXIT_OK}
 364
 365         # If the SIM card is in an unknown state, we cannot do anything.
 366         elif [ ${sim_status_code} -eq ${EXIT_SIM_UNKNOWN} ]; then
 367                 error "The SIM card is in an unknown state."
 368                 exit ${EXIT_ERROR}
 369         fi
 370
 371         # Ask for the code.
 372         local code=${2}
 373         local require_new_pin="false"
 374         local new_pin
 375
 376         while ! isinteger code; do
 377                 local message
 378                 case "${sim_status_code}" in
 379                         ${EXIT_SIM_PIN})
 380                                 message="Please enter PIN:"
 381                                 ;;
 382                         ${EXIT_SIM_PUK})
 383                                 message="Please enter PUK:"
 384                                 require_new_pin="true"
 385                                 ;;
 386                 esac
 387                 assert isset message
 388
 389                 echo -n "${message} "
 390                 read -s code
 391                 echo # Print newline.
 392
 393                 if enabled require_new_pin; then
 394                         local i new_pin2
 395                         for i in 0 1; do
 396                                 case "${i}" in
 397                                         0)
 398                                                 message="Please enter a new PIN code:"
 399                                                 ;;
 400                                         1)
 401                                                 message="Please confirm the new PIN code:"
 402                                                 ;;
 403                                 esac
 404
 405                                 echo -n "${message} "
 406                                 read -s new_pin2
 407                                 echo # Print newline.
 408
 409                                 if [ -n "${new_pin}" ]; then
 410                                         if [ "${new_pin}" != "${new_pin2}" ]; then
 411                                                 error "The entered PIN codes did not match."
 412                                                 exit ${EXIT_ERROR}
 413                                         fi
 414                                 else
 415                                         new_pin=${new_pin2}
 416                                 fi
 417                         done
 418                 fi
 419         done
 420
 421         # Trying to unlock the SIM card.
 422         modem_sim_unlock ${device} ${code} ${new_pin}
 423
 424         exit $?
 425 }
 426
 427 cli_device_send_ussd_command() {
 428         local device="${1}"
 429         assert isset device
 430         shift
 431
 432         local command
 433         local timeout
 434
 435         while [ $# -gt 0 ]; do
 436                 case "${1}" in
 437                         --timeout=*)
 438                                 timeout="$(cli_get_val "${1}")"
 439                                 ;;
 440                         *)
 441                                 if isset command; then
 442                                         warning "Unrecognized argument: ${1}"
 443                                 else
 444                                         command="${1}"
 445                                 fi
 446                                 ;;
 447                 esac
 448                 shift
 449         done
 450
 451         assert device_is_serial "${device}"
 452
 453         local args
 454         if isset timeout; then
 455                 args="${args} --timeout=${timeout}"
 456         fi
 457
 458         modem_ussd_send_command "${device}" "${command}" ${args}
 459         exit $?
 460 }
 461
 462 cli_device_monitor() {
 463         local device="${1}"
 464         assert isset device
 465
 466         if ! device_is_wireless "${device}"; then
 467                 error "This action only works with wireless devices. Exiting."
 468                 exit ${EXIT_ERROR}
 469         fi
 470
 471         wireless_monitor "${device}"
 472         exit $?
 473 }
 474
 475 cli_device_list() {
 476         local device
 477         for device in $(device_list); do
 478                 cli_device_status "${device}"
 479         done
 480
 481         exit ${EXIT_OK}
 482 }
 483
 484 cli_hostname() {
 485         if cli_help_requested $@; then
 486                 cli_show_man network
 487                 exit ${EXIT_OK}
 488         fi
 489
 490         local hostname=${1}
 491
 492         if [ -n "${hostname}" ]; then
 493                 config_hostname ${hostname}
 494                 log INFO "Hostname was set to '${hostname}'."
 495                 log INFO "Changes do only take affect after reboot."
 496                 exit ${EXIT_OK}
 497         fi
 498
 499         echo "$(config_hostname)"
 500         exit ${EXIT_OK}
 501 }
 502
 503 cli_port() {
 504         if cli_help_requested $@; then
 505                 cli_show_man network-port
 506                 exit ${EXIT_OK}
 507         fi
 508
 509         local action
 510         local port
 511
 512         if port_exists ${1}; then
 513                 port=${1}
 514                 action=${2}
 515                 shift 2
 516
 517                 case "${action}" in
 518                         edit|create|remove|up|down|status|identify)
 519                                 port_${action} "${port}" $@
 520                                 ;;
 521                         color)
 522                                 color_cli "port" "${port}" $@
 523                                 ;;
 524                         description)
 525                                 description_cli "port" "${port}" $@
 526                                 ;;
 527                         *)
 528                                 error "Unrecognized argument: ${action}"
 529                                 exit ${EXIT_ERROR}
 530                                 ;;
 531                 esac
 532         else
 533                 action=${1}
 534                 shift
 535
 536                 case "${action}" in
 537                         new|destroy)
 538                                 port_${action} $@
 539                                 ;;
 540                         *)
 541                                 error "Unrecognized argument: ${action}"
 542                                 exit ${EXIT_ERROR}
 543                                 ;;
 544                 esac
 545         fi
 546 }
 547
 548 cli_zone() {
 549         if cli_help_requested $@; then
 550                 cli_show_man network-zone
 551                 exit ${EXIT_OK}
 552         fi
 553
 554         local action
 555         local zone
 556
 557         if zone_exists ${1}; then
 558                 zone=${1}
 559                 action=${2}
 560                 shift 2
 561
 562                 # Action aliases
 563                 case "${action}" in
 564                         start|reload)
 565                                 action="up"
 566                                 ;;
 567                         stop)
 568                                 action="down"
 569                                 ;;
 570                         show)
 571                                 action="status"
 572                                 ;;
 573                 esac
 574
 575                 case "${action}" in
 576                         port)
 577                                 cli_zone_port "${zone}" $@
 578                                 ;;
 579                         rename)
 580                                 cli_zone_rename "${zone}" $@
 581                                 ;;
 582                         config|disable|down|edit|enable|identify|status|up)
 583                                 zone_${action} ${zone} $@
 584                                 ;;
 585                         color)
 586                                 color_cli "zone" "${zone}" $@
 587                                 ;;
 588                         description)
 589                                 description_cli "zone" ${zone} $@
 590                                 ;;
 591                         *)
 592                                 error "Unrecognized argument: ${action}"
 593                                 cli_show_man network-zone
 594                                 exit ${EXIT_ERROR}
 595                                 ;;
 596                 esac
 597         else
 598                 action=${1}
 599                 shift
 600
 601                 case "${action}" in
 602                         new)
 603                                 cli_zone_new $@
 604                                 ;;
 605                         destroy)
 606                                 cli_zone_destroy $@
 607                                 ;;
 608                         ""|*)
 609                                 if [ -n "${action}" ]; then
 610                                         error "Unrecognized argument: '${action}'"
 611                                         echo
 612                                 fi
 613
 614                                 cli_show_man network-zone
 615                                 exit ${EXIT_ERROR}
 616                                 ;;
 617                 esac
 618         fi
 619 }
 620
 621 cli_zone_new() {
 622         if cli_help_requested $@ || [ $# -lt 2 ]; then
 623                 cli_show_man network-zone-new
 624                 exit ${EXIT_OK}
 625         fi
 626
 627         zone_new $@
 628 }
 629
 630 # Removes a zone either immediately, if it is currently down,
 631 # or adds a tag that the removal will be done when the zone
 632 # is brought down the next time.
 633 cli_zone_destroy() {
 634         if cli_help_requested $@; then
 635                 cli_show_man network-zone
 636                 exit ${EXIT_OK}
 637         fi
 638
 639         local zone="${1}"
 640         assert zone_exists "${zone}"
 641
 642         if zone_is_up ${zone}; then
 643                 echo "Zone '${zone}' is up and will be removed when it goes down the next time."
 644                 zone_destroy "${zone}"
 645         else
 646                 echo "Removing zone '${zone}' now..."
 647                 zone_destroy_now "${zone}"
 648         fi
 649
 650         exit ${EXIT_OK}
 651 }
 652
 653 cli_zone_port() {
 654         if cli_help_requested $@; then
 655                 cli_show_man network-zone-port
 656                 exit ${EXIT_OK}
 657         fi
 658
 659         local zone="${1}"
 660         assert zone_exists "${zone}"
 661
 662         if port_exists "${2}"; then
 663                 local port="${2}"
 664                 local action="${3}"
 665                 shift 3
 666
 667                 case "${action}" in
 668                         edit)
 669                                 zone_port_edit "${zone}" "${port}" $@
 670                                 ;;
 671                         *)
 672                                 error "Unrecognised argument: ${action}"
 673                                 exit ${EXIT_ERROR}
 674                                 ;;
 675                 esac
 676         else
 677                 local action="${2}"
 678                 shift 2
 679
 680                 case "${action}" in
 681                         attach)
 682                                 zone_port_attach "${zone}" $@
 683                                 ;;
 684                         detach)
 685                                 zone_port_detach "${zone}" $@
 686                                 ;;
 687                         *)
 688                                 error "Unrecognised argument: ${action}"
 689                                 exit ${EXIT_ERROR}
 690                                 ;;
 691                 esac
 692         fi
 693
 694         exit ${EXIT_OK}
 695 }
 696
 697 cli_zone_rename() {
 698         if cli_help_requested $@; then
 699                 cli_show_man network-zone
 700                 exit ${EXIT_OK}
 701         fi
 702
 703         local zone="${1}"
 704         local name="${2}"
 705         shift 2
 706
 707         if ! isset name; then
 708                 error "You need to pass a new name"
 709                 exit ${EXIT_ERROR}
 710         fi
 711
 712         if ! zone_name_is_valid "${name}"; then
 713                 error "Invalid new zone name: ${name}"
 714                 exit ${EXIT_ERROR}
 715         fi
 716
 717         # Check if the zone exists
 718         if ! zone_exists "${zone}"; then
 719                 error "Zone ${zone} does not exist"
 720                 exit ${EXIT_ERROR}
 721         fi
 722
 723         # Destroyed zones cannot be renamed
 724         if zone_has_destroy_tag "${zone}"; then
 725                 error "Zone ${zone} is about to be destroyed and cannot be renamed"
 726                 exit ${EXIT_ERROR}
 727         fi
 728
 729         # Check if a zone with the new name already exists
 730         if zone_exists "${name}"; then
 731                 error "Zone ${name} already exists"
 732                 exit ${EXIT_ERROR}
 733         fi
 734
 735         # Rename
 736         if ! zone_rename "${zone}" "${name}"; then
 737                 error "Could not rename zone ${zone} to ${name}"
 738                 exit ${EXIT_ERROR}
 739         fi
 740
 741         exit ${EXIT_OK}
 742 }
 743
 744 cli_list_hooks() {
 745         local type=${1}
 746         shift
 747
 748         if cli_help_requested $@; then
 749                 cli_show_man network-zone
 750                 exit ${EXIT_OK}
 751         fi
 752
 753         local hook_dir=$(hook_dir ${type})
 754         local hook
 755
 756         for hook in ${hook_dir}/*; do
 757                 hook=$(basename ${hook})
 758                 if hook_exists ${type} ${hook}; then
 759                         echo "${hook}"
 760                 fi
 761         done | sort -u
 762 }
 763
 764 cli_route() {
 765         if cli_help_requested $@; then
 766                 cli_show_man network-route
 767                 exit ${EXIT_OK}
 768         fi
 769
 770         local action=${1}
 771         shift
 772
 773         case "${action}" in
 774                 static)
 775                         cli_route_static $@
 776                         ;;
 777                 *)
 778                         error "Unrecognized action: ${action}"
 779                         cli_run_help network route
 780
 781                         exit ${EXIT_ERROR}
 782                         ;;
 783         esac
 784
 785         exit ${EXIT_OK}
 786
 787
 788 }
 789
 790 cli_route_static() {
 791         if cli_help_requested $@; then
 792                 cli_show_man network-route-static
 793                 exit ${EXIT_OK}
 794         fi
 795
 796         local action=${1}
 797         shift
 798
 799         case "${action}" in
 800                 # Add a new route.
 801                 add)
 802                         route_add $@
 803                         ;;
 804                 # Remove an existing route.
 805                 remove)
 806                         route_remove $@
 807                         ;;
 808                 # List all routes.
 809                 list)
 810                         route_list $@
 811                         return ${EXIT_OK}
 812                         ;;
 813                 # Reload all routes.
 814                 reload)
 815                         route_apply $@
 816                         ;;
 817                 *)
 818                         error "Unrecognized action: ${action}"
 819                         cli_run_help network route
 820
 821                         exit ${EXIT_ERROR}
 822                         ;;
 823         esac
 824
 825         # Applying all routes.
 826         route_apply
 827
 828         exit ${EXIT_OK}
 829 }
 830
 831 cli_dhcpd() {
 832         local proto=${1}
 833         shift
 834
 835         if cli_help_requested $@; then
 836                 cli_show_man network-dhcp
 837                 exit ${EXIT_OK}
 838         fi
 839
 840         local action=${1}
 841         shift
 842
 843         case "${action}" in
 844                 edit)
 845                         dhcpd_edit ${proto} $@
 846                         ;;
 847                 start)
 848                         dhcpd_start ${proto}
 849
 850                         # Make this permanent
 851                         dhcpd_enable ${proto}
 852                         ;;
 853                 stop)
 854                         dhcpd_stop ${proto}
 855
 856                         # Make this permanent
 857                         dhcpd_disable ${proto}
 858                         ;;
 859                 restart|reload)
 860                         dhcpd_reload ${proto}
 861                         ;;
 862                 subnet)
 863                         cli_dhcpd_subnet ${proto} $@
 864                         ;;
 865                 show|"")
 866                         cli_dhcpd_show ${proto} $@
 867                         ;;
 868                 *)
 869                         error "Unrecognized action: ${action}"
 870                         cli_run_help network dhcpvN
 871
 872                         exit ${EXIT_ERROR}
 873                         ;;
 874         esac
 875
 876         exit ${EXIT_OK}
 877 }
 878
 879 cli_dhcpd_show() {
 880         local proto=${1}
 881         assert isset proto
 882
 883         local settings=$(dhcpd_settings ${proto})
 884         assert isset settings
 885
 886         local ${settings}
 887         dhcpd_global_settings_read ${proto}
 888
 889         cli_headline 1 "Dynamic Host Configuration Protocol Daemon for ${proto/ip/IP}"
 890
 891         case "${proto}" in
 892                 ipv6)
 893                         cli_headline 2 "Lease times"
 894                         if isinteger VALID_LIFETIME; then
 895                                 cli_print_fmt1 2 "Valid lifetime" "$(format_time ${VALID_LIFETIME})"
 896                         fi
 897
 898                         if isinteger PREFERRED_LIFETIME; then
 899                                 cli_print_fmt1 2 "Preferred lifetime" "$(format_time ${PREFERRED_LIFETIME})"
 900                         fi
 901
 902                         cli_space
 903                         ;;
 904                 ipv4)
 905                         cli_print_fmt1 1 "Authoritative" $(cli_print_enabled AUTHORITATIVE)
 906                         cli_space
 907
 908                         cli_headline 2 "Lease times"
 909                         cli_print_fmt1 2 "Default lease time" "$(format_time ${DEFAULT_LEASE_TIME})"
 910                         cli_print_fmt1 2 "Max. lease time" "$(format_time ${MAX_LEASE_TIME})"
 911
 912                         if isset MIN_LEASE_TIME; then
 913                                 cli_print_fmt1 2 "Min. lease time" "$(format_time ${MIN_LEASE_TIME})"
 914                         fi
 915
 916                         cli_space
 917                         ;;
 918         esac
 919
 920         # Read the options.
 921         local -A options
 922         dhcpd_global_options_read ${proto}
 923
 924         # Print the options if any.
 925         if [ ${#options[*]} -gt 0 ]; then
 926                 cli_headline 2 "Options"
 927
 928                 local option
 929                 for option in $(dhcpd_options ${proto}); do
 930                         [ -n "${options[${option}]}" ] || continue
 931
 932                         cli_print_fmt1 2 \
 933                                 "${option}" "${options[${option}]}"
 934                 done
 935                 cli_space
 936         fi
 937
 938         # Subnets.
 939         local subnets=$(dhcpd_subnet_list ${proto})
 940         if [ -n "${subnets}" ]; then
 941                 cli_headline 2 "Subnets"
 942                 local subnet
 943                 for subnet in ${subnets}; do
 944                         cli_dhcpd_subnet_show ${proto} ${subnet} 2
 945                 done
 946         fi
 947 }
 948
 949 cli_dhcpd_subnet() {
 950         assert [ $# -ge 1 ]
 951
 952         local proto=${1}
 953         shift
 954
 955         if cli_help_requested $@; then
 956                 cli_show_man network-dhcp-subnet
 957                 exit ${EXIT_OK}
 958         fi
 959
 960         local action=${1}
 961         shift
 962
 963         case "${action}" in
 964                 new)
 965                         dhcpd_subnet_new ${proto} $@
 966                         ;;
 967                 remove)
 968                         dhcpd_subnet_remove ${proto} $@
 969                         ;;
 970                 *:*/*|*.*.*.*/*)
 971                         local subnet=${action}
 972
 973                         if ! dhcpd_subnet_exists ${proto} ${subnet}; then
 974                                 error "Subnet ${subnet} does not exist"
 975                                 return ${EXIT_ERROR}
 976                         fi
 977
 978                         # Update the action.
 979                         action=${1}
 980                         shift
 981
 982                         case "${action}" in
 983                                 edit)
 984                                         dhcpd_subnet_edit ${proto} ${subnet} $@
 985                                         local ret=$?
 986
 987                                         if [ ${ret} -eq ${EXIT_OK} ]; then
 988                                                 dhcpd_reload ${proto}
 989                                         fi
 990                                         exit ${ret}
 991                                         ;;
 992                                 range)
 993                                         cli_dhcpd_subnet_range ${proto} ${subnet} $@
 994                                         exit $?
 995                                         ;;
 996                                 show)
 997                                         cli_dhcpd_subnet_show ${proto} ${subnet} $@
 998                                         exit $?
 999                                         ;;
1000                                 options)
1001                                         cli_dhcpd_subnet_options ${proto} ${subnet} $@
1002                                         exit $?
1003                                         ;;
1004                                 *)
1005                                         error "Unrecognized action: ${action}"
1006                                         cli_run_help network dhcpvN subnet
1007                                         exit ${EXIT_ERROR}
1008                                         ;;
1009                         esac
1010                         ;;
1011                 show)
1012                         local subnet
1013                         for subnet in $(dhcpd_subnet_list ${proto}); do
1014                                 cli_dhcpd_subnet_show ${proto} ${subnet}
1015                         done
1016                         ;;
1017                 *)
1018                         error "Unrecognized action: ${action}"
1019                         cli_run_help network dhcpvN subnet
1020
1021                         exit ${EXIT_ERROR}
1022                         ;;
1023         esac
1024
1025         exit ${EXIT_OK}
1026 }
1027
1028 cli_dhcpd_subnet_range() {
1029         assert [ $# -ge 2 ]
1030
1031         local proto=${1}
1032         local subnet=${2}
1033         local action=${3}
1034         shift 3
1035
1036         case "${action}" in
1037                 new)
1038                         dhcpd_subnet_range_new ${proto} ${subnet} $@ || exit ${EXIT_ERROR}
1039                         ;;
1040                 remove)
1041                         dhcpd_subnet_range_remove ${proto} ${subnet} $@ || exit ${EXIT_ERROR}
1042                         ;;
1043                 *)
1044                         error "Unrecognized action: ${action}"
1045                         cli_run_help network dhcpvN subnet range
1046                         exit ${EXIT_ERROR}
1047                         ;;
1048         esac
1049
1050         dhcpd_reload ${proto}
1051         return ${EXIT_OK}
1052 }
1053
1054 cli_dhcpd_subnet_show() {
1055         assert [ $# -ge 2 -a $# -le 3 ]
1056
1057         local proto=${1}
1058         local subnet=${2}
1059
1060         local level=${3}
1061         isset level || level=0
1062
1063         local $(dhcpd_subnet_settings ${proto})
1064
1065         # Read in configuration settings.
1066         dhcpd_subnet_read ${proto} ${subnet}
1067
1068         cli_headline $(( ${level} + 1 )) "DHCP Subnet Declaration"
1069         cli_print_fmt1 $(( ${level} + 1 )) \
1070                 "Subnet" "${ADDRESS}/${PREFIX}"
1071         cli_space
1072
1073         # Read the options.
1074         local -A options
1075         dhcpd_subnet_options_read "${proto}" "${subnet}"
1076
1077         # Print the options if any.
1078         if [ ${#options[*]} -gt 0 ]; then
1079                 cli_headline $(( ${level} + 2 )) "Options"
1080
1081                 local option
1082                 for option in $(dhcpd_subnet_options_list ${proto}); do
1083                         [ -n "${options[${option}]}" ] || continue
1084
1085                         cli_print_fmt1 $(( ${level} + 2 )) \
1086                                 "${option}" "${options[${option}]}"
1087                 done
1088                 cli_space
1089         fi
1090
1091         # Ranges.
1092         cli_headline $(( ${level} + 2 )) "Ranges"
1093
1094         local ranges=$(dhcpd_subnet_range_list ${proto} ${subnet})
1095         if isset ranges; then
1096                 local range $(dhcpd_subnet_range_settings ${proto})
1097                 for range in ${ranges}; do
1098                         dhcpd_subnet_range_read ${proto} ${subnet} ${range}
1099
1100                         cli_print $(( ${level} + 2 )) "%s - %s" ${START} ${END}
1101                 done
1102         else
1103                 cli_print $(( ${level} + 2 )) "No ranges have been defined."
1104         fi
1105
1106         cli_space
1107 }
1108
1109 cli_dhcpd_subnet_options() {
1110         assert [ $# -eq 2 ]
1111
1112         local proto=${1}
1113         local subnet=${2}
1114
1115         local key val
1116         while [ $# -gt 0 ]; do
1117                 case "${1}" in
1118                         *=*)
1119                                 key=$(cli_get_key ${1})
1120                                 val=$(cli_get_val ${1})
1121
1122                                 dhcpd_subnet_option_set ${proto} ${subnet} ${key} ${val}
1123                 esac
1124         done
1125 }
1126
1127 cli_start() {
1128         if cli_help_requested $@; then
1129                 cli_show_man network
1130                 exit ${EXIT_OK}
1131         fi
1132
1133         local zones=$(zones_get $@)
1134
1135         local zone
1136         for zone in ${zones}; do
1137                 zone_start ${zone} &
1138         done
1139
1140         wait # until everything is settled
1141 }
1142
1143 cli_stop() {
1144         if cli_help_requested $@; then
1145                 cli_show_man network
1146                 exit ${EXIT_OK}
1147         fi
1148
1149         local zones=$(zones_get $@)
1150
1151         local zone
1152         for zone in ${zones}; do
1153                 zone_stop ${zone} &
1154         done
1155
1156         wait # until everything is settled
1157 }
1158
1159 cli_restart() {
1160         if cli_help_requested $@; then
1161                 cli_show_man network
1162                 exit ${EXIT_OK}
1163         fi
1164
1165         cli_stop $@
1166
1167         # Give the system some time to calm down
1168         sleep ${TIMEOUT_RESTART}
1169
1170         cli_start $@
1171 }
1172
1173 cli_status() {
1174         if cli_help_requested $@; then
1175                 cli_show_man network
1176                 exit ${EXIT_OK}
1177         fi
1178
1179         # When dumping status information, the debug
1180         # mode clutters the console which is not what we want.
1181         # Logging on the console is disabled for a short time.
1182         local log_disable_stdout=${LOG_DISABLE_STDOUT}
1183         LOG_DISABLE_STDOUT="true"
1184
1185         local zones=$(zones_get $@)
1186
1187         local zone
1188         for zone in ${zones}; do
1189                 zone_status ${zone}
1190         done
1191
1192         # Reset logging.
1193         LOG_DISABLE_STDOUT=${log_disable_stdout}
1194 }
1195
1196 cli_reset() {
1197         if cli_help_requested $@; then
1198                 cli_show_man network
1199                 exit ${EXIT_OK}
1200         fi
1201
1202         warning_log "Will reset the whole network configuration!!!"
1203         # Force mode is disabled by default
1204         local force=0
1205
1206         while [ $# -gt 0 ]; do
1207                 case "${1}" in
1208                         --force|-f)
1209                                 force=1
1210                                 ;;
1211                 esac
1212                 shift
1213         done
1214
1215         # If we are not running in force mode, we ask the user if he does know
1216         # what he is doing.
1217         if ! enabled force; then
1218                 if ! cli_yesno "Do you really want to reset the whole network configuration?"; then
1219                         exit ${EXIT_ERROR}
1220                 fi
1221         fi
1222
1223         local zone
1224         for zone in $(zones_get --all); do
1225                 zone_destroy_now "${zone}"
1226         done
1227
1228         local port
1229         for port in $(ports_get --all); do
1230                 port_destroy "${port}"
1231         done
1232
1233         # Flush all DNS servers.
1234         dns_server_flush
1235
1236         # Re-run the initialization functions
1237         init_run
1238
1239         exit ${EXIT_OK}
1240 }
1241
1242 # Help function: will show the default man page to the user.
1243 # Optionally, there are two arguments taken, the type of hook
1244 # and which hook should be shown.
1245 cli_help() {
1246         local cmd=${1}
1247         shift
1248
1249         case "${cmd}" in
1250                 zone|port|config)
1251                         local type=${cmd}
1252                         local hook=${1}
1253
1254                         # List all hooks if requested
1255                         if [ "${hook}" = "list-hooks" ]; then
1256                                 cli_list_hooks ${type}
1257                                 return ${EXIT_OK}
1258                         fi
1259
1260                         if ! hook_exists ${type} ${hook}; then
1261                                 error "No hook with name '${hook}' could be found"
1262                                 exit "${EXIT_ERROR}"
1263                         fi
1264
1265                         hook_exec ${type} ${hook} help
1266                         ;;
1267
1268                 # In all other cases show the default man page
1269                 *)
1270                         cli_show_man network
1271                         return ${EXIT_OK}
1272                         ;;
1273         esac
1274
1275         return ${EXIT_ERROR}
1276 }
1277
1278 cli_dns_server() {
1279         if cli_help_requested $@; then
1280                 cli_show_man network-dns-server
1281                 exit ${EXIT_OK}
1282         fi
1283
1284         # Get the command.
1285         local cmd=${1}; shift
1286         if [ -z "${cmd}" ]; then
1287                 cli_show_man network-dns-server
1288                 exit ${EXIT_ERROR}
1289         fi
1290
1291         # Get the new server to process (if any).
1292         local server=${1}
1293         local priority=${2}
1294
1295         case "${cmd}" in
1296                 list)
1297                         dns_server_show
1298                         exit ${EXIT_OK}
1299                         ;;
1300                 add)
1301                         if dns_server_exists ${server}; then
1302                                 error "DNS server '${server}' already exists!"
1303                                 exit ${EXIT_ERROR}
1304                         fi
1305
1306                         log INFO "Adding new DNS server: ${server}"
1307                         dns_server_add ${server} ${priority}
1308                         ;;
1309                 remove)
1310                         if ! dns_server_exists ${server}; then
1311                                 error "DNS server '${server}' does not exist!"
1312                                 exit ${EXIT_ERROR}
1313                         fi
1314
1315                         log INFO "Removing DNS server: ${server}"
1316                         dns_server_remove ${server} ${priority}
1317                         ;;
1318                 update)
1319                         # Just run the update afterwards.
1320                         ;;
1321                 *)
1322                         error "No such command: ${cmd}"
1323                         exit ${EXIT_ERROR}
1324         esac
1325
1326         # Update the local DNS configuration after changes have been made.
1327         dns_server_update
1328
1329         exit ${EXIT_OK}
1330 }
1331
1332 cli_raw() {
1333         local cmd="${1}"
1334         assert isset cmd
1335         shift
1336
1337         case "${cmd}" in
1338                 db-dump)
1339                         db_dump
1340                         ;;
1341                 list-devices)
1342                         device_list
1343                         ;;
1344                 list-dhcpd-ranges-of-subnet)
1345                         dhcpd_subnet_range_list $@
1346                         ;;
1347                 list-dhcpd-settings)
1348                         dhcpd_global_settings_list $@
1349                         ;;
1350                 list-dhcpd-subnets)
1351                         dhcpd_subnet_list $@
1352                         ;;
1353                 list-dhcpd-subnet-options)
1354                         dhcpd_subnet_options_list $@
1355                         ;;
1356                 list-dns-servers)
1357                         dns_server_list
1358                         ;;
1359                 list-free-ports)
1360                         port_list_free
1361                         ;;
1362                 list-hooks)
1363                         hook_list $@
1364                         ;;
1365                 list-ports)
1366                         port_list
1367                         ;;
1368                 list-ports-of-zone)
1369                         zone_get_ports $@
1370                         ;;
1371                 list-settings)
1372                         network_settings_list
1373                         ;;
1374                 list-zones)
1375                         zones_get_all
1376                         ;;
1377                 list-next-free-zones)
1378                         zones_get_next_free
1379                         ;;
1380                 list-zone-config-ids)
1381                         zone_config_list_ids $@
1382                         ;;
1383                 list-zone-config-hids)
1384                         zone_config_list_hids $@
1385                         ;;
1386                 zone-name-is-valid)
1387                         zone_name_is_valid $@
1388                         ;;
1389                 zone-config-id-is-valid)
1390                         zone_config_id_is_valid $@
1391                         ;;
1392                 zone-config-hid-is-valid)
1393                         zone_config_hid_is_valid $@
1394                         ;;
1395                 *)
1396                         error "No such command: ${cmd}"
1397                         exit ${EXIT_ERROR}
1398                         ;;
1399         esac
1400
1401         exit ${EXIT_OK}
1402 }
1403
1404 cli_vpn() {
1405         local action=${1}
1406         shift 1
1407
1408         case "${action}" in
1409                 security-policies)
1410                         cli_vpn_security_policies $@
1411                         ;;
1412                 *)
1413                         error "Unrecognized argument: ${action}"
1414                         exit ${EXIT_ERROR}
1415                         ;;
1416         esac
1417 }
1418
1419 cli_vpn_security_policies() {
1420
1421         local action
1422         local security_policy
1423
1424         if vpn_security_policy_exists ${1}; then
1425
1426                 security_policy=${1}
1427                 key=${2}
1428                 shift 2
1429
1430                 case "${key}" in
1431                         cipher|compression|integrity|lifetime|pfs|show)
1432                                 vpn_security_policies_${key} ${security_policy} $@
1433                                 ;;
1434                         group-type)
1435                                 vpn_security_policies_group_type ${security_policy} $@
1436                                 ;;
1437                         key-exchange)
1438                                 vpn_security_policies_key_exchange ${security_policy} $@
1439                                 ;;
1440                         *)
1441                                 error "Unrecognized argument: ${key}"
1442                                 exit ${EXIT_ERROR}
1443                                 ;;
1444                 esac
1445         else
1446                 action=${1}
1447                 shift
1448
1449                 case "${action}" in
1450                         new)
1451                                 vpn_security_policies_new $@
1452                                 ;;
1453                         destroy)
1454                                 vpn_security_policies_destroy $@
1455                                 ;;
1456                         ""|*)
1457                                 if [ -n "${action}" ]; then
1458                                         error "Unrecognized argument: '${action}'"
1459                                 fi
1460                                 exit ${EXIT_ERROR}
1461                                 ;;
1462                 esac
1463         fi
1464 }
1465
1466 # Process the given action
1467 case "${action}" in
1468         init)
1469                 init_run
1470                 ;;
1471
1472         settings|hostname|port|device|zone|start|stop|restart|status|reset|route|vpn)
1473                 cli_${action} $@
1474                 ;;
1475
1476         # DHCP server configuration (automatically detects which protocol to use).
1477         dhcpv6|dhcpv4)
1478                 cli_dhcpd ${action/dhcp/ip} $@
1479                 ;;
1480
1481         # DNS server configuration.
1482         dns-server)
1483                 cli_dns_server $@
1484                 ;;
1485
1486         ""|help|--help|-h)
1487                 cli_help $@
1488                 ;;
1489
1490         raw)
1491                 cli_raw $@
1492                 ;;
1493
1494         *)
1495                 error "Invalid command given: ${action}"
1496                 cli_usage "network help"
1497                 exit ${EXIT_CONF_ERROR}
1498                 ;;
1499 esac
1500
1501 exit ${EXIT_OK}