src/functions/functions.ports

   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 ports_get_all() {
  23         local port
  24         for port in $(list_directory "${NETWORK_PORTS_DIR}"); do
  25                 if port_exists "${port}"; then
  26                         print "${port}"
  27                 fi
  28         done
  29 }
  30
  31 # XXX TO BE REMOVED
  32 port_list() {
  33         ports_get_all "$@"
  34 }
  35
  36 port_list_in_use() {
  37         local ports_in_use
  38
  39         # Collect all ports that are attached to a zone
  40         local zone
  41         for zone in $(zones_get_all); do
  42                 list_append ports_in_use $(zone_get_ports "${zone}")
  43         done
  44
  45         # Collect all ports that are enslaved by an other port
  46         local port
  47         for port in $(port_list); do
  48                 list_append ports_in_use $(port_get_slaves "${port}")
  49         done
  50
  51         list_sort ${ports_in_use}
  52 }
  53
  54 port_list_free() {
  55         local ports_in_use="$(port_list_in_use)"
  56
  57         local port
  58         for port in $(port_list); do
  59                 if ! list_match "${port}" ${ports_in_use}; then
  60                         print "${port}"
  61                 fi
  62         done
  63
  64         return ${EXIT_OK}
  65 }
  66
  67 port_get_hook() {
  68         local port=${1}
  69         assert isset port
  70
  71         config_get_hook $(port_file ${port})
  72 }
  73
  74 port_config_dir() {
  75         local port=${1}
  76
  77         print "${RUN_DIR}/ports/${port}"
  78         return ${EXIT_OK}
  79 }
  80
  81 port_settings_read() {
  82         local port="${1}"
  83         assert isset port
  84
  85         # Save the HOOK variable.
  86         local hook="${HOOK}"
  87
  88         settings_read "$(port_file "${port}")" ${HOOK_SETTINGS}
  89
  90         # Restore hook.
  91         HOOK="${hook}"
  92 }
  93
  94 port_settings_write() {
  95         local port="${1}"
  96         assert isset port
  97         shift
  98
  99         local args
 100         if function_exists "hook_check_settings"; then
 101                 list_append args "--check=\"hook_check_settings\""
 102         fi
 103         list_append args HOOK ${HOOK_SETTINGS}
 104
 105         settings_write "$(port_file "${port}")" ${args}
 106 }
 107
 108 port_file() {
 109         local port="${1}"
 110         assert isset port
 111
 112         echo "${NETWORK_PORTS_DIR}/${port}/settings"
 113 }
 114
 115 port_exists() {
 116         local port=${1}
 117
 118         [ -d "${NETWORK_CONFIG_DIR}/ports/${port}" ]
 119 }
 120
 121 port_get_hook() {
 122         local port=${1}
 123
 124         assert isset port
 125
 126         config_get_hook $(port_file ${port})
 127 }
 128
 129 port_is_attached() {
 130         local port=${1}
 131         shift
 132
 133         assert isset port
 134
 135         local zone
 136         for zone in $(zones_get_all); do
 137                 if list_match ${port} $(zone_get_ports ${zone}); then
 138                         echo "${zone}"
 139                         return ${EXIT_OK}
 140                 fi
 141         done
 142
 143         return ${EXIT_ERROR}
 144 }
 145
 146 port_is_up() {
 147         device_is_up "$@"
 148 }
 149
 150 port_new() {
 151         local hook="${1}"
 152         shift
 153
 154         if ! hook_exists port "${hook}"; then
 155                 error "Port hook '${hook}' does not exist."
 156                 return ${EXIT_ERROR}
 157         fi
 158
 159         hook_exec port "${hook}" new "$@"
 160 }
 161
 162 port_destroy() {
 163         local port=${1}
 164         assert isset port
 165
 166         # Cannot delete a port that does not exist
 167         if ! port_exists ${port}; then
 168                 error "No such port: ${port}"
 169                 return ${EXIT_ERROR}
 170         fi
 171
 172         local attached_zone=$(port_is_attached ${port})
 173         if [ -n "${attached_zone}" ]; then
 174                 if ! zone_port_detach "${attached_zone}" "${port}"; then
 175                         error "Could not remove port ${port} from zone ${zone}"
 176                         return ${EXIT_ERROR}
 177                 fi
 178         fi
 179
 180         # Check if the port is linked to any other port and don't allow the user
 181         # to delete it.
 182         local other_port
 183         for other_port in $(ports_get); do
 184                 [ "${other_port}" = "${port}" ] && continue
 185
 186                 if list_match ${port} $(port_get_children ${other_port}); then
 187                         log ERROR "Cannot destroy port '${port}' which is child of port '${other_port}'."
 188                         return ${EXIT_ERROR}
 189                 fi
 190         done
 191
 192         # Shut down the port before destroying it
 193         if ! port_remove "${port}"; then
 194                 return ${EXIT_ERROR}
 195         fi
 196
 197         if ! rm -rf "${NETWORK_PORTS_DIR}/${port}"; then
 198                 log ERROR "Could not destroy port ${port}"
 199                 return ${EXIT_ERROR}
 200         fi
 201
 202         log INFO "Destroyed port ${port}"
 203         return ${EXIT_OK}
 204 }
 205
 206 port_create() {
 207         port_cmd "create" "$@"
 208 }
 209
 210 port_remove() {
 211         local port="${1}"
 212         assert isset port
 213
 214         if ! port_exists "${port}"; then
 215                 log ERROR "Port ${port} does not exist"
 216                 return ${EXIT_ERROR}
 217         fi
 218
 219         # If the device is still up, we need to bring it down first.
 220         if device_is_up "${port}"; then
 221                 port_down "${port}"
 222         fi
 223
 224         port_cmd "remove" "${port}"
 225 }
 226
 227 # Restarts the port by removing it and then re-creating it
 228 port_restart() {
 229         local port="${1}"
 230         assert isset port
 231
 232         port_remove "${port}"
 233
 234         port_create "${port}"
 235 }
 236
 237 port_edit() {
 238         port_cmd edit "$@"
 239 }
 240
 241 port_up() {
 242         assert [ $# -eq 1 ]
 243
 244         local port="${1}"
 245
 246         # Check if the port exists
 247         if ! device_exists "${port}"; then
 248                 log ERROR "Could not bring up port ${port} which has not been created"
 249                 return ${EXIT_ERROR}
 250         fi
 251
 252         port_cmd up "${port}"
 253 }
 254
 255 port_down() {
 256         port_cmd down "$@"
 257 }
 258
 259 port_status() {
 260         port_cmd status "$@"
 261 }
 262
 263 port_cmd() {
 264         local cmd=${1}
 265         local port=${2}
 266         shift 2
 267
 268         assert isset cmd
 269         assert isset port
 270
 271         local hook=$(port_get_hook ${port})
 272
 273         # Abort if we could not find a hook
 274         if ! isset hook; then
 275                 log CRITICAL "Port ${port} does not have a hook associated with it"
 276                 return ${EXIT_ERROR}
 277         fi
 278
 279         hook_exec port ${hook} ${cmd} ${port} "$@"
 280 }
 281
 282 ports_get() {
 283         local port
 284         for port in $(list_directory "${NETWORK_PORTS_DIR}"); do
 285                 if port_exists ${port}; then
 286                         echo "${port}"
 287                 fi
 288         done
 289 }
 290
 291 port_find_free() {
 292         local pattern=${1}
 293
 294         assert isset pattern
 295
 296         local port
 297         local i=0
 298
 299         while [ ${i} -lt 99 ]; do
 300                 port=${pattern//N/${i}}
 301                 if ! port_exists ${port} && ! device_exists ${port}; then
 302                         echo "${port}"
 303                         return ${EXIT_OK}
 304                 fi
 305                 i=$(( ${i} + 1 ))
 306         done
 307
 308         return ${EXIT_ERROR}
 309 }
 310
 311 port_get_children() {
 312         local port=${1}
 313
 314         assert port_exists "${port}"
 315
 316         port_cmd "children" "${port}"
 317 }
 318
 319 port_zone() {
 320         # Get name of the zones, this port is configured in.
 321         local port=${1}
 322         shift
 323
 324         assert isset port
 325
 326         local zone
 327         for zone in $(zones_get_all); do
 328                 if zone_has_port ${zone} ${port}; then
 329                         echo "${zone}"
 330                         return ${EXIT_OK}
 331                 fi
 332         done
 333
 334         return ${EXIT_OK}
 335 }
 336
 337 port_hotplug_event() {
 338         local port="${1}"
 339         assert isset port
 340
 341         hotplug_assert_in_hotplug_event
 342
 343         port_cmd "hotplug" "${port}"
 344 }
 345
 346 port_get_slaves() {
 347         local port="${1}"
 348
 349         port_settings_read "${port}" \
 350                 --ignore-superfluous-settings SLAVES
 351         print "${SLAVES}"
 352 }
 353
 354 port_device_is_slave() {
 355         assert [ $# -eq 2 ]
 356
 357         local port="${1}"
 358         local device="${2}"
 359
 360         # Get slaves of port
 361         local slaves="$(port_get_slaves "${port}")"
 362
 363         # Returns true if device is in slaves
 364         list_match "${device}" ${slaves}
 365 }
 366
 367 port_get_phy() {
 368         local port="${1}"
 369
 370         port_settings_read "${port}" \
 371                 --ignore-superfluous-settings PHY
 372         print "${PHY}"
 373 }
 374
 375 port_uses_phy() {
 376         assert [ $# -eq 2 ]
 377
 378         local port="${1}"
 379         local phy="${2}"
 380
 381         # Nothing to do if an empty argument is given
 382         if ! isset phy; then
 383                 return ${EXIT_FALSE}
 384         fi
 385
 386         phy="$(phy_get_address "${phy}")"
 387
 388         local port_phy="$(port_get_phy "${port}")"
 389         [ "${port_phy}" = "${phy}" ]
 390 }
 391
 392 ports_lowest_address() {
 393         local address
 394         local addresses
 395
 396         local port
 397         for port in $(port_list); do
 398                 # Skip all ports that do not exist
 399                 # any more or are not plugged in
 400                 device_exists "${port}" || continue
 401
 402                 # Skip all ports that are not proper ethernet devices
 403                 device_is_wireless "${port}" && continue
 404                 device_is_ethernet "${port}" || continue
 405
 406                 list_append addresses "$(device_get_address "${port}")"
 407         done
 408
 409         # Sort the list
 410         addresses="$(list_sort ${addresses})"
 411
 412         # Get the first element which is the lowest MAC address
 413         list_head ${addresses}
 414 }
 415
 416 port_identify() {
 417         device_identify "$@"
 418 }
 419
 420 port_get_color() {
 421         # This function return the color of a port
 422         assert [ $# -eq 1 ]
 423
 424         local name=${1}
 425         color_read "port" ${name}
 426 }
 427
 428 port_get_description_title() {
 429         assert [ $# -eq 1 ]
 430
 431         local name=${1}
 432         description_title_read $(description_format_filename "port" "${name}")
 433 }