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