src/functions/functions.wireless

   1 #!/bin/bash
   2 ###############################################################################
   3 #                                                                             #
   4 # IPFire.org - A linux based firewall                                         #
   5 # Copyright (C) 2012  IPFire Network Development Team                         #
   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 # Sets the global wireless country code. Default is 00 = world.
  23 WIRELESS_REGULATORY_DOMAIN="00"
  24 NETWORK_SETTINGS_FILE_PARAMS="${NETWORK_SETTINGS_FILE_PARAMS} WIRELESS_REGULATORY_DOMAIN"
  25
  26 WIRELESS_REGULATORY_DOMAIN_DATABASE="/usr/lib/crda/regulatory.bin"
  27
  28 WIRELESS_DEFAULT_ENCRYPTION_MODE="NONE"
  29 WIRELESS_VALID_ENCRYPTION_MODES="WPA2-PSK-SHA256 WPA2-PSK \
  30         WPA-PSK-SHA256 WPA-PSK NONE"
  31
  32 declare -A WIRELESS_CHANNEL_BANDWIDTHS=(
  33         ["802.11ac"]="20 40 80 160 80+80"
  34         ["802.11a/n"]="20 40"
  35         ["802.11a"]="20 40"
  36         ["802.11g/n"]="20 40"
  37         ["802.11g"]="20 40"
  38 )
  39
  40 cli_wireless() {
  41         local action=${1}
  42         shift 1
  43
  44         case "${action}" in
  45                 network)
  46                         cli_wireless_network "$@"
  47                         ;;
  48                 *)
  49                         error "Unrecognized argument: ${action}"
  50                         exit ${EXIT_ERROR}
  51                         ;;
  52         esac
  53 }
  54
  55 wireless_create() {
  56         local device=${1}
  57         assert isset device
  58         shift
  59
  60         local address
  61         local channel
  62         local phy
  63         local type="managed"
  64
  65         while [ $# -gt 0 ]; do
  66                 case "${1}" in
  67                         --address=*)
  68                                 address=$(cli_get_val "${1}")
  69                                 ;;
  70                         --channel=*)
  71                                 channel=$(cli_get_val "${1}")
  72                                 ;;
  73                         --phy=*)
  74                                 phy=$(cli_get_val "${1}")
  75                                 phy=$(phy_get ${phy})
  76                                 ;;
  77                         --type=*)
  78                                 type=$(cli_get_val "${1}")
  79
  80                                 # ap --> __ap
  81                                 [ "${type}" = "ap" ] && type="__ap"
  82                                 ;;
  83                         *)
  84                                 error "Unrecognized argument: ${1}"
  85                                 return ${EXIT_ERROR}
  86                                 ;;
  87                 esac
  88                 shift
  89         done
  90
  91         case "${type}" in
  92                 ibss|managed|monitor|__ap)
  93                         ;;
  94                 mesh-point)
  95                         type="mp"
  96                         ;;
  97                 *)
  98                         log ERROR "Unknown type: ${type}"
  99                         return ${EXIT_ERROR}
 100                         ;;
 101
 102         esac
 103
 104         assert phy_exists ${phy}
 105         isset address || address=$(mac_generate)
 106
 107         cmd_quiet iw phy ${phy} interface add ${device} type ${type}
 108         local ret=$?
 109
 110         if [ ${ret} -eq ${EXIT_OK} ]; then
 111                 log DEBUG "created wireless device '${device}' (${type})"
 112
 113                 if isset address; then
 114                         device_set_address ${device} ${address}
 115                 fi
 116         else
 117                 log ERROR "could not create wireless device '${device}' (${type}): ${ret}"
 118         fi
 119
 120         # Set the channel
 121         if isset channel; then
 122                 wireless_set_channel "${device}" "${channel}" "auto" || return $?
 123         fi
 124
 125         return ${ret}
 126 }
 127
 128 wireless_remove() {
 129         local device=${1}
 130         assert isset device
 131
 132         if ! device_exists ${device}; then
 133                 return ${EXIT_OK}
 134         fi
 135
 136         # Tear down the device (if necessary).
 137         device_set_down ${device}
 138
 139         # Remove it.
 140         cmd_quiet iw dev ${device} del
 141         local ret=$?
 142
 143         if [ ${ret} -eq ${EXIT_OK} ]; then
 144                 log DEBUG "removed wireless device '${device}'"
 145         else
 146                 log ERROR "could not remove wireless device '${device}': ${ret}"
 147         fi
 148
 149         return ${ret}
 150 }
 151
 152 wireless_get_reg_domain() {
 153         # Returns the country code for the wireless device.
 154         # Defaults to 00 = world if unset.
 155         print "${WIRELESS_REGULATORY_DOMAIN:-00}"
 156 }
 157
 158 wireless_init_reg_domain() {
 159         local country_code="$(wireless_get_reg_domain)"
 160
 161         wireless_set_reg_domain "${country_code}" --no-reset
 162 }
 163
 164 wireless_set_reg_domain() {
 165         local country_code
 166         local reset="true"
 167
 168         while [ $# -gt 0 ]; do
 169                 case "${1}" in
 170                         --no-reset)
 171                                 reset="false"
 172                                 ;;
 173                         -*)
 174                                 log ERROR "Ignoring invalid option: ${1}"
 175                                 ;;
 176                         *)
 177                                 country_code="${1}"
 178                                 ;;
 179                 esac
 180                 shift
 181         done
 182
 183         # Check if configuration value is valid
 184         if ! wireless_valid_reg_domain "${country_code}"; then
 185                 log ERROR "Invalid wireless regulatory domain: ${country_code}"
 186                 return ${EXIT_ERROR}
 187         fi
 188
 189         # Before the wireless reg domain is set, it helps to reset to 00 first.
 190         if enabled reset; then
 191                 iw reg set 00 &>/dev/null
 192         fi
 193
 194         log INFO "Setting wireless regulatory domain country to '${country_code}'"
 195         iw reg set "${country_code}"
 196 }
 197
 198 wireless_valid_reg_domain() {
 199         local country_code="${1}"
 200
 201         # Empty country codes are invalid
 202         isset country_code || return ${EXIT_FALSE}
 203
 204         local valid_country_codes="$(wireless_list_reg_domains)"
 205
 206         if list_match "${country_code}" ${valid_country_codes}; then
 207                 return ${EXIT_TRUE}
 208         fi
 209
 210         return ${EXIT_FALSE}
 211 }
 212
 213 wireless_list_reg_domains() {
 214         if [ ! -r "${WIRELESS_REGULATORY_DOMAIN_DATABASE}" ]; then
 215                 log ERROR "Could not read ${WIRELESS_REGULATORY_DOMAIN_DATABASE}"
 216                 return ${EXIT_ERROR}
 217         fi
 218
 219         local line
 220         while read line; do
 221                 # Check if line starts with "country"
 222                 [ "${line:0:7}" = "country" ] || continue
 223
 224                 # Print country code
 225                 print "${line:8:2}"
 226         done <<< "$(regdbdump ${WIRELESS_REGULATORY_DOMAIN_DATABASE})"
 227 }
 228
 229 # http://en.wikipedia.org/wiki/List_of_WLAN_channels
 230 wireless_channel_to_frequency() {
 231         local channel=${1}
 232
 233         # Works only for valid channel numbers
 234         if ! wireless_channel_is_valid "${channel}"; then
 235                 log ERROR "Invalid wireless channel: ${channel}"
 236                 return ${EXIT_ERROR}
 237         fi
 238
 239         # 2.4 GHz band
 240         case "${channel}" in
 241                 [123456789]|1[0123])
 242                         print "$(( 2407 + (${channel} * 5)))"
 243                         return ${EXIT_OK}
 244                         ;;
 245                 14)
 246                         print "2484"
 247                         return ${EXIT_OK}
 248                         ;;
 249         esac
 250
 251         # 5 GHz band
 252         case "${channel}" in
 253                 3[68]|4[02468]|5[26]|6[04]|10[048]|11[26]|12[048]|13[26]|14[09]|15[37]|16[15])
 254                         print "$(( 5000 + (${channel} * 5)))"
 255                         return ${EXIT_OK}
 256                         ;;
 257         esac
 258
 259         return ${EXIT_ERROR}
 260 }
 261
 262 wireless_frequency_to_channel() {
 263         local frequency=${1}
 264
 265         assert isinteger frequency
 266
 267         # Everything that is too high
 268         if [ ${frequency} -gt 5825 ]; then
 269                 return ${EXIT_ERROR}
 270
 271         # 5 GHz Band
 272         elif [ ${frequency} -gt 5000 ]; then
 273                 (( frequency = frequency - 5000 ))
 274
 275                 # Must be divisible by 5
 276                 [ "$(( frequency % 5 ))" -ne 0 ] && return ${EXIT_ERROR}
 277
 278                 print "$(( frequency / 5 ))"
 279
 280         # 2.4 GHz Band - Channel 14
 281         elif [ ${frequency} -eq 2484 ]; then
 282                 print "14"
 283
 284         # 2.4 GHz Band
 285         elif [ ${frequency} -gt 2407 ]; then
 286                 (( frequency = frequency - 2407 ))
 287
 288                 # Must be divisible by 5
 289                 [ "$(( frequency % 5 ))" -ne 0 ] && return ${EXIT_ERROR}
 290
 291                 print "$(( frequency / 5 ))"
 292
 293         # Everything else
 294         else
 295                 return ${EXIT_ERROR}
 296         fi
 297
 298         return ${EXIT_OK}
 299 }
 300
 301 wireless_channel_is_valid() {
 302         local channel=${1}
 303
 304         case "${channel}" in
 305                 # 2.4 GHz Band
 306                 [123456789]|1[0123]|14)
 307                         return ${EXIT_TRUE}
 308                         ;;
 309
 310                 # 5 GHz Band
 311                 3[68]|4[02468]|5[26]|6[04]|10[048]|11[26]|12[048]|13[26]|14[09]|15[37]|16[15])
 312                         return ${EXIT_TRUE}
 313                         ;;
 314         esac
 315
 316         # Invalid channel number given
 317         return ${EXIT_FALSE}
 318 }
 319
 320 wireless_channel_bandwidth_is_valid() {
 321         local mode="${1}"
 322         assert isset mode
 323
 324         local bandwidth="${2}"
 325         assert isset bandwidth
 326
 327         local bandwidths="${WIRELESS_CHANNEL_BANDWIDTHS["${mode}"]}"
 328
 329         list_match "${bandwidth}" ${bandwidths}
 330 }
 331
 332 wireless_channel_is_ht40_plus() {
 333         local channel="${1}"
 334         assert isinteger channel
 335
 336         # 2.4 GHz
 337         if [ ${channel} -le 6 ]; then
 338                 return ${EXIT_TRUE}
 339         fi
 340
 341         return ${EXIT_FALSE}
 342 }
 343
 344 wireless_channel_is_ht40_minus() {
 345         local channel="${1}"
 346         assert isinteger channel
 347
 348         # 2.4 GHz
 349         if [ ${channel} -ge 6 ]; then
 350                 return ${EXIT_TRUE}
 351         fi
 352
 353         return ${EXIT_FALSE}
 354 }
 355
 356 wireless_set_channel() {
 357         local device="${1}"
 358         local channel="${2}"
 359         local bandwidth="${3}"
 360
 361         # Check if the device exists
 362         if ! device_exists "${device}"; then
 363                 log ERROR "No such device: ${device}"
 364                 return ${EXIT_ERROR}
 365         fi
 366
 367         # Check if the channel number is valid
 368         if ! wireless_channel_is_valid "${channel}"; then
 369                 log ERROR "Invalid wireless channel: ${channel}"
 370                 return ${EXIT_ERROR}
 371         fi
 372
 373         local ht_flag
 374         if [ "${bandwidth}" = "auto" ]; then
 375                 local phy="$(device_get_phy "${device}")"
 376
 377                 # Offset of a 40 MHz channel
 378                 local ht_offset=5
 379
 380                 if wireless_channel_is_ht40_plus "${channel}" \
 381                                 && phy_supports_ht_capability "${phy}" "HT40+" \
 382                                 && phy_supports_channel "${phy}" $(( channel + ht_offset )); then
 383                         ht_flag="HT40+"
 384
 385                 elif wireless_channel_is_ht40_minus "${channel}" \
 386                                 && phy_supports_ht_capability "${phy}" "HT40-" \
 387                                 && phy_supports_channel "${phy}" $(( channel - ht_offset )); then
 388                         ht_flags="HT40-"
 389                 fi
 390         fi
 391
 392         log DEBUG "Setting wireless channel on device '${device}' to channel '${channel}'"
 393         cmd iw dev "${device}" set channel "${channel}" "${ht_flag}"
 394 }
 395
 396 wireless_pre_shared_key_is_valid() {
 397         local encryption_mode="${1}"
 398         local psk="${2}"
 399
 400         # Length of the PSK
 401         local l="${#psk}"
 402
 403         case "${encryption_mode}" in
 404                 # For WPA*, the key must be between 8 and 63 chars
 405                 WPA2-PSK|WPA2-PSK-SHA256|WPA-PSK|WPA-PSK-SHA256)
 406                         if [ ${l} -ge 8 ] && [ ${l} -le 63 ]; then
 407                                 return ${EXIT_TRUE}
 408                         fi
 409
 410                         return ${EXIT_FALSE}
 411                         ;;
 412         esac
 413
 414         return ${EXIT_ERROR}
 415 }
 416
 417 wireless_client_is_connected() {
 418         local device="${1}"
 419
 420         device_has_carrier "${device}"
 421 }
 422
 423 wireless_ibss_join() {
 424         local device=${1}
 425         assert isset device
 426         shift
 427
 428         local bssid
 429         local essid
 430         local frequency
 431
 432         while [ $# -gt 0 ]; do
 433                 case "${1}" in
 434                         --bssid=*)
 435                                 bssid="$(cli_get_val "${1}")"
 436                                 ;;
 437                         --essid=*)
 438                                 essid="$(cli_get_val "${1}")"
 439                                 ;;
 440                         --channel=*)
 441                                 local channel="$(cli_get_val "${1}")"
 442
 443                                 # Save the frequency of the channel instead
 444                                 # of the channel itself.
 445                                 if isset channel; then
 446                                         frequency="$(wireless_channel_to_frequency ${channel})"
 447                                 fi
 448                                 ;;
 449                 esac
 450                 shift
 451         done
 452
 453         # Check input.
 454         assert ismac bssid
 455         assert isset essid
 456         assert isinteger frequency
 457
 458         # Set device up.
 459         device_set_up "${device}"
 460
 461         log INFO "${device} joining ibss network: ${essid} (${bssid})"
 462         cmd_quiet iw dev "${device}" ibss join "${essid}" \
 463                 "${frequency}" fixed-freq "${bssid}"
 464 }
 465
 466 wireless_ibss_leave() {
 467         local device=${1}
 468         assert isset device
 469
 470         log INFO "${device} leaving ibss network"
 471         cmd_quiet iw dev "${device}" ibss leave
 472 }
 473
 474 wireless_is_radar_frequency() {
 475         local frequency="${1}"
 476         assert isset frequency
 477
 478         [[ ${frequency} -ge 5260 ]] && [[ ${frequency} -le 5700 ]]
 479 }
 480
 481 wireless_monitor() {
 482         local device="${1}"
 483         assert isset device
 484         shift
 485
 486         local monitor_device="$(port_find_free "${PORT_PATTERN_WIRELESS_MONITOR}")"
 487
 488         # Create an 802.11 monitoring device
 489         wireless_create "${monitor_device}" --phy="${device}" --type="monitor"
 490         local ret=$?
 491
 492         case "${ret}" in
 493                 0)
 494                         # Bring up the device
 495                         device_set_up "${monitor_device}"
 496
 497                         # Starting tcpdump
 498                         tcpdump -i "${monitor_device}" "$@"
 499
 500                         # Remove the monitoring interface.
 501                         wireless_remove "${monitor_device}"
 502                         ;;
 503
 504                 *)
 505                         log ERROR "Could not create a monitoring interface on ${device}"
 506                         return ${EXIT_ERROR}
 507                         ;;
 508         esac
 509
 510         return ${EXIT_OK}
 511 }
 512
 513 wireless_get_ht_caps() {
 514         local device="${1}"
 515         assert isset device
 516
 517         local phy="$(device_get_phy "${device}")"
 518         if ! isset phy; then
 519                 log ERROR "Could not determine PHY for ${device}"
 520                 return ${EXIT_ERROR}
 521         fi
 522
 523         network-phy-list-ht-caps "${phy}"
 524 }
 525
 526 wireless_get_vht_caps() {
 527         local device="${1}"
 528         assert isset device
 529
 530         local phy="$(device_get_phy "${device}")"
 531         if ! isset phy; then
 532                 log ERROR "Could not determine PHY for ${device}"
 533                 return ${EXIT_ERROR}
 534         fi
 535
 536         network-phy-list-vht-caps "${phy}"
 537 }
 538
 539 wireless_supports_acs() {
 540         local device="${1}"
 541         assert isset device
 542
 543         local phy="$(device_get_phy "${device}")"
 544         if ! isset phy; then
 545                 log ERROR "Could not determine PHY for ${device}"
 546                 return ${EXIT_ERROR}
 547         fi
 548
 549         phy_supports_acs "${phy}"
 550 }
 551
 552 wireless_supports_dfs() {
 553         local device="${1}"
 554         assert isset device
 555
 556         local phy="$(device_get_phy "${device}")"
 557         if ! isset phy; then
 558                 log ERROR "Could not determine PHY for ${device}"
 559                 return ${EXIT_ERROR}
 560         fi
 561
 562         phy_supports_dfs "${phy}"
 563 }