functions.ppp

   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 PPP_SUPPORTED_AUTH_METHODS="chap pap"
  23
  24 function pppd_start() {
  25         local interface=${1}
  26         assert isset interface
  27
  28         # This will block until the connection has been established or
  29         # pppd exited.
  30         service_start "pppd@${interface}.service"
  31
  32         # Get the exit code of the ppp daemon and figure out
  33         # how to handle this.
  34         local ret=$(service_get_exitcode "pppd@${interface}.service")
  35         case "${ret}" in
  36                 0)
  37                         return ${EXIT_OK}
  38                         ;;
  39                 1)
  40                         error "pppd crashed for an unknown reason"
  41                         ;;
  42                 2)
  43                         error "pppd: Configuration error"
  44                         ;;
  45                 5)
  46                         error "pppd terminated"
  47                         ;;
  48                 16)
  49                         error "pppd: Link terminated by modem"
  50                         ;;
  51                 19)
  52                         error "pppd: Authentication failed"
  53                         ;;
  54                 *)
  55                         error "pppd: Unhandled exit code: ${ret}"
  56                         ;;
  57         esac
  58
  59         return ${ret}
  60 }
  61
  62 function pppd_stop() {
  63         local interface=${1}
  64         assert isset interface
  65
  66         service_stop "pppd@${interface}.service"
  67 }
  68
  69 function pppd_status() {
  70         local interface=${1}
  71         assert isset interface
  72
  73         service_status "pppd@${interface}.service"
  74 }
  75
  76 function ppp_common_ip_pre_up() {
  77         local zone=${1}
  78         shift
  79
  80         if ! zone_exists ${zone}; then
  81                 error "Zone '${zone}' does not exist."
  82                 return ${EXIT_ERROR}
  83         fi
  84
  85         routing_db_from_ppp ${zone} ipv4
  86
  87         return ${EXIT_OK}
  88 }
  89
  90 function ppp_common_ip_up() {
  91         local zone=${1}
  92         shift
  93
  94         if ! zone_exists ${zone}; then
  95                 error "Zone '${zone}' does not exist."
  96                 return ${EXIT_ERROR}
  97         fi
  98
  99         routing_db_set ${zone} ipv4 active 1
 100         routing_update ${zone} ipv4
 101         routing_default_update
 102
 103         return ${EXIT_OK}
 104 }
 105
 106 function ppp_common_ip_down() {
 107         local zone=${1}
 108         shift
 109
 110         if ! zone_exists ${zone}; then
 111                 error "Zone '${zone}' does not exist."
 112                 return ${EXIT_ERROR}
 113         fi
 114
 115         # Remove the information about this zone from the routing database
 116         # and update the routing table.
 117         routing_db_remove ${zone} ipv4
 118         routing_update ${zone} ipv4
 119         routing_default_update
 120
 121         # Save accounting information
 122         ppp_accounting ${zone}
 123
 124         return ${EXIT_OK}
 125 }
 126
 127 function ppp_common_ipv6_up() {
 128         local zone=${1}
 129         shift
 130
 131         if ! zone_exists ${zone}; then
 132                 error "Zone '${zone}' does not exist."
 133                 return ${EXIT_ERROR}
 134         fi
 135
 136         # Add information about this zone to the routing database.
 137         routing_db_from_ppp ${zone} ipv6
 138
 139         routing_db_set ${zone} ipv6 active 1
 140         routing_update ${zone} ipv6
 141         routing_default_update
 142
 143         return ${EXIT_OK}
 144 }
 145
 146 function ppp_common_ipv6_down() {
 147         local zone=${1}
 148         shift
 149
 150         if ! zone_exists ${zone}; then
 151                 error "Zone '${zone}' does not exist."
 152                 return ${EXIT_ERROR}
 153         fi
 154
 155         # Remove the information about this zone from the routing database
 156         # and update the routing table.
 157         routing_db_remove ${zone} ipv6
 158         routing_update ${zone} ipv6
 159         routing_default_update
 160
 161         # Save accounting information
 162         ppp_accounting ${zone}
 163
 164         return ${EXIT_OK}
 165 }
 166
 167 function ppp_secret() {
 168         local USER=${1}
 169         local SECRET=${2}
 170         local a
 171         local secret
 172         local user
 173
 174         # Updateing secret file
 175         > ${PPP_SECRETS}.tmp
 176         while read user a secret; do
 177                 if [ "'${USER}'" != "${user}" ]; then
 178                         echo "${user} ${a} ${secret}" >> ${PPP_SECRETS}.tmp
 179                 fi
 180         done < ${PPP_SECRETS}
 181         echo "'${USER}' * '${SECRET}'" >> ${PPP_SECRETS}.tmp
 182         cat ${PPP_SECRETS}.tmp > ${PPP_SECRETS}
 183         rm -f ${PPP_SECRETS}.tmp
 184 }
 185
 186 function ppp_accounting() {
 187         local zone=${1}
 188         shift
 189
 190         db_ppp_update ${zone} --duration="${CONNECT_TIME}" \
 191                 --rcvd="${BYTES_RCVD}" --sent="${BYTES_SENT}"
 192 }
 193
 194 function pppd_exec() {
 195         log DEBUG "Running pppd with parameters '$@'."
 196
 197         pppd $@ > /dev/null
 198 }
 199
 200 function pppd_write_config() {
 201         local file=${1}; shift
 202         assert isset file
 203
 204         local auth
 205         local baudrate
 206         local connect_cmd
 207         local default_asyncmap="true"
 208         local interface
 209         local lcp_echo_failure=3
 210         local lcp_echo_interval=20
 211         local linkname
 212         local mtu mru
 213         local password
 214         local plugin plugin_options
 215         local serial="false"
 216         local username
 217         local value
 218
 219         while [ $# -gt 0 ]; do
 220                 case "${1}" in
 221                         --auth=*)
 222                                 auth=$(cli_get_val ${1})
 223                                 ;;
 224                         --baudrate=*)
 225                                 baudrate=$(cli_get_val ${1})
 226                                 assert isoneof baudrate ${SERIAL_BAUDRATES}
 227                                 ;;
 228                         --connect-command=*)
 229                                 connect_cmd=$(cli_get_val ${1})
 230                                 ;;
 231                         # Enable or disable the use of the default asyncmap.
 232                         --default-asyncmap=*)
 233                                 value=$(cli_get_val ${1})
 234                                 if enabled value; then
 235                                         default_asyncmap="true"
 236                                 else
 237                                         default_asyncmap="false"
 238                                 fi
 239                                 ;;
 240                         # The name of the created ppp interface.
 241                         --interface=*)
 242                                 interface=$(cli_get_val ${1})
 243                                 ;;
 244                         # LCP echo failure.
 245                         --lcr-echo-failure=*)
 246                                 lcr_echo_failure=$(cli_get_val ${1})
 247
 248                                 if ! isinteger ${lcr_echo_failure}; then
 249                                         error "--lcr-echo-failure= requires a number"
 250                                         return ${EXIT_ERROR}
 251                                 fi
 252                                 ;;
 253                         # LCP echo interval.
 254                         --lcr-echo-interval=*)
 255                                 lcr_echo_interval=$(cli_get_val ${1})
 256
 257                                 if ! isinteger ${lcr_echo_failure}; then
 258                                         error "--lcr-echo-interval= requires a number"
 259                                         return ${EXIT_ERROR}
 260                                 fi
 261                                 ;;
 262                         # Maximum Transmission Unit
 263                         --mtu=*)
 264                                 mtu=$(cli_get_val ${1})
 265                                 ;;
 266                         # Maximum Receive Unit
 267                         --mru=*)
 268                                 mru=$(cli_get_val ${1})
 269                                 ;;
 270                         --password=*)
 271                                 password=$(cli_get_val ${1})
 272                                 ;;
 273                         --plugin=*)
 274                                 plugin=$(cli_get_val ${1})
 275                                 ;;
 276                         --plugin-options=*)
 277                                 plugin_options=$(cli_get_val ${1})
 278                                 ;;
 279                         # Sets if the modem is a serial device.
 280                         --serial=*)
 281                                 serial=$(cli_get_val ${1})
 282                                 ;;
 283                         --serial-device=*)
 284                                 serial_device=$(cli_get_val ${1})
 285                                 ;;
 286                         --username=*)
 287                                 username=$(cli_get_val ${1})
 288                                 ;;
 289                         *)
 290                                 log WARNING "Unhandled argument: ${1}"
 291                                 ;;
 292                 esac
 293                 shift
 294         done
 295
 296         if [ -z "${interface}" ]; then
 297                 log ERROR "You need to set the interface name: ${interface}"
 298                 return ${EXIT_ERROR}
 299         fi
 300         linkname="${interface}"
 301
 302         if isset auth; then
 303                 if ! isoneof ${auth} ${PPP_SUPPORTED_AUTH_METHODS}; then
 304                         log ERROR "Unsupported auth method: ${auth}"
 305                         return ${EXIT_ERROR}
 306                 fi
 307         fi
 308
 309         if enabled serial; then
 310                 assert isset serial_device
 311                 assert [ -c "${serial_device}" ]
 312         fi
 313
 314         # Set the user credentials.
 315         ppp_secret "${username}" "${password}"
 316
 317         # Write the configuration header.
 318         mkdir -p $(dirname ${file}) 2>/dev/null
 319         config_header "PPP daemon configuration file" > ${file}
 320
 321         # At first, set the name of the link.
 322         print "linkname ${linkname}\n" >> ${file}
 323
 324         # Configure the interface/zone name.
 325         (
 326                 print "# Interface name"
 327                 print "ifname ${interface}"
 328                 print
 329         ) >> ${file}
 330
 331         # Plugin settings
 332         if isset plugin; then
 333                 (
 334                         print "# Plugin settings"
 335                         print "plugin ${plugin} ${plugin_options}"
 336                         print
 337                 ) >> ${file}
 338         fi
 339
 340         # User authentication
 341         if isset username; then
 342                 (
 343                         print "# User authentication"
 344                         print "user ${username}"
 345
 346                         print "noauth"
 347                         if isset auth; then
 348                                 print "require-${auth}"
 349                         fi
 350                         print
 351                 ) >> ${file}
 352         fi
 353
 354         # MTU/MRU settings
 355         if isset mtu; then
 356                 isset mru || mru=${mtu}
 357
 358                 (
 359                         print "# MTU/MRU settings"
 360                         print "mtu ${mtu}"
 361                         print "mru ${mru}"
 362                         print
 363                 ) >> ${file}
 364         fi
 365
 366         if enabled serial; then
 367                 (
 368                         print "# Serial modem settings"
 369                         print "${serial_device} ${baudrate}"
 370                         print "crtscts"
 371                         print "lock"
 372                         print "modem"
 373                         print
 374                 ) >> ${file}
 375
 376                 # Connect command
 377                 if isset connect_cmd; then
 378                         (
 379                                 print "# Connect command"
 380                                 print "connect \"${connect_cmd}\""
 381                                 print
 382                         ) >> ${file}
 383                 fi
 384         fi
 385
 386         # Default asyncmap.
 387         if enabled default_asyncmap; then
 388                 (
 389                         print "# Use the default asyncmap."
 390                         print "default-asyncmap"
 391                         print
 392                 ) >> ${file}
 393         fi
 394
 395         # LCP settings.
 396         (
 397                 print "# LCP settings"
 398                 print "lcp-echo-failure ${lcp_echo_failure}"
 399                 print "lcp-echo-interval ${lcp_echo_interval}"
 400                 print
 401         ) >> ${file}
 402
 403         # Add the default settings.
 404         (
 405                 print "# Disable the compression"
 406                 print "noccp noaccomp nodeflate nopcomp novj novjccomp nobsdcomp nomppe"
 407
 408                 print "noipdefault updetach debug"
 409         ) >> ${file}
 410
 411         return ${EXIT_OK}
 412 }