Pau Espin Pedrol | fdd732b | 2017-10-13 14:32:24 +0200 | [diff] [blame] | 1 | /* |
Harald Welte | 632e843 | 2017-09-05 18:12:14 +0200 | [diff] [blame] | 2 | * OsmoGGSN - Gateway GPRS Support Node |
jjako | 0fe0df0 | 2004-09-17 11:30:40 +0000 | [diff] [blame] | 3 | * Copyright (C) 2002, 2003, 2004 Mondru AB. |
Harald Welte | 7bdc80d | 2019-04-11 18:47:59 +0200 | [diff] [blame] | 4 | * Copyright (C) 2017-2019 by Harald Welte <laforge@gnumonks.org> |
Pau Espin Pedrol | fdd732b | 2017-10-13 14:32:24 +0200 | [diff] [blame] | 5 | * |
jjako | a7cd249 | 2003-04-11 09:40:12 +0000 | [diff] [blame] | 6 | * The contents of this file may be used under the terms of the GNU |
| 7 | * General Public License Version 2, provided that the above copyright |
| 8 | * notice and this permission notice is included in all copies or |
| 9 | * substantial portions of the software. |
Pau Espin Pedrol | fdd732b | 2017-10-13 14:32:24 +0200 | [diff] [blame] | 10 | * |
jjako | 52c2414 | 2002-12-16 13:33:51 +0000 | [diff] [blame] | 11 | */ |
| 12 | |
| 13 | /* ggsn.c |
| 14 | * |
| 15 | */ |
| 16 | |
| 17 | #ifdef __linux__ |
| 18 | #define _GNU_SOURCE 1 /* strdup() prototype, broken arpa/inet.h */ |
| 19 | #endif |
| 20 | |
jjako | 0fe0df0 | 2004-09-17 11:30:40 +0000 | [diff] [blame] | 21 | #include "../config.h" |
| 22 | |
| 23 | #ifdef HAVE_STDINT_H |
| 24 | #include <stdint.h> |
| 25 | #endif |
jjako | 52c2414 | 2002-12-16 13:33:51 +0000 | [diff] [blame] | 26 | |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 27 | #include <getopt.h> |
jjako | 52c2414 | 2002-12-16 13:33:51 +0000 | [diff] [blame] | 28 | #include <ctype.h> |
jjako | 52c2414 | 2002-12-16 13:33:51 +0000 | [diff] [blame] | 29 | #include <signal.h> |
| 30 | #include <stdio.h> |
| 31 | #include <string.h> |
| 32 | #include <stdlib.h> |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 33 | #include <unistd.h> |
| 34 | #include <inttypes.h> |
| 35 | #include <errno.h> |
jjako | 52c2414 | 2002-12-16 13:33:51 +0000 | [diff] [blame] | 36 | #include <sys/types.h> |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 37 | #include <sys/ioctl.h> |
| 38 | |
| 39 | #include <net/if.h> |
| 40 | #include <arpa/inet.h> |
jjako | 52c2414 | 2002-12-16 13:33:51 +0000 | [diff] [blame] | 41 | #include <netinet/in.h> |
Harald Welte | 63ebccd | 2017-08-02 21:10:09 +0200 | [diff] [blame] | 42 | #include <netinet/ip.h> |
Harald Welte | a0d281d | 2017-08-02 21:48:16 +0200 | [diff] [blame] | 43 | #include <netinet/ip6.h> |
jjako | 52c2414 | 2002-12-16 13:33:51 +0000 | [diff] [blame] | 44 | |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 45 | #include <osmocom/core/application.h> |
Max | 727417d | 2016-08-02 17:10:38 +0200 | [diff] [blame] | 46 | #include <osmocom/core/select.h> |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 47 | #include <osmocom/core/stats.h> |
| 48 | #include <osmocom/core/rate_ctr.h> |
| 49 | #include <osmocom/core/timer.h> |
Harald Welte | 7bdc80d | 2019-04-11 18:47:59 +0200 | [diff] [blame] | 50 | #include <osmocom/core/utils.h> |
Max | 727417d | 2016-08-02 17:10:38 +0200 | [diff] [blame] | 51 | #include <osmocom/ctrl/control_if.h> |
| 52 | #include <osmocom/ctrl/control_cmd.h> |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 53 | #include <osmocom/ctrl/control_vty.h> |
Max | 727417d | 2016-08-02 17:10:38 +0200 | [diff] [blame] | 54 | #include <osmocom/ctrl/ports.h> |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 55 | #include <osmocom/vty/telnet_interface.h> |
| 56 | #include <osmocom/vty/logging.h> |
| 57 | #include <osmocom/vty/stats.h> |
| 58 | #include <osmocom/vty/ports.h> |
| 59 | #include <osmocom/vty/command.h> |
Harald Welte | 3e443ca | 2018-02-14 01:04:04 +0100 | [diff] [blame] | 60 | #include <osmocom/vty/misc.h> |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 61 | #include <osmocom/gsm/apn.h> |
Max | 727417d | 2016-08-02 17:10:38 +0200 | [diff] [blame] | 62 | |
Emmanuel Bretelle | 2a10368 | 2010-09-07 17:01:20 +0200 | [diff] [blame] | 63 | #include "../lib/tun.h" |
| 64 | #include "../lib/ippool.h" |
| 65 | #include "../lib/syserr.h" |
Harald Welte | d12eab9 | 2017-08-02 19:49:47 +0200 | [diff] [blame] | 66 | #include "../lib/in46_addr.h" |
Harald Welte | f228639 | 2018-04-25 19:02:31 +0200 | [diff] [blame] | 67 | #include "../lib/gtp-kernel.h" |
jjako | 52c2414 | 2002-12-16 13:33:51 +0000 | [diff] [blame] | 68 | #include "../gtp/pdp.h" |
| 69 | #include "../gtp/gtp.h" |
Harald Welte | d46bcd2 | 2017-08-08 23:27:22 +0200 | [diff] [blame] | 70 | #include "icmpv6.h" |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 71 | #include "ggsn.h" |
jjako | 52c2414 | 2002-12-16 13:33:51 +0000 | [diff] [blame] | 72 | |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 73 | void *tall_ggsn_ctx; |
jjako | a7cd249 | 2003-04-11 09:40:12 +0000 | [diff] [blame] | 74 | |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 75 | static int end = 0; |
| 76 | static int daemonize = 0; |
| 77 | static struct ctrl_handle *g_ctrlh; |
| 78 | |
jjako | a7cd249 | 2003-04-11 09:40:12 +0000 | [diff] [blame] | 79 | struct ul255_t qos; |
| 80 | struct ul255_t apn; |
| 81 | |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 82 | #define LOGPAPN(level, apn, fmt, args...) \ |
| 83 | LOGP(DGGSN, level, "APN(%s): " fmt, (apn)->cfg.name, ## args) |
jjako | 52c2414 | 2002-12-16 13:33:51 +0000 | [diff] [blame] | 84 | |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 85 | #define LOGPGGSN(level, ggsn, fmt, args...) \ |
| 86 | LOGP(DGGSN, level, "GGSN(%s): " fmt, (ggsn)->cfg.name, ## args) |
| 87 | |
Max | 6a21527 | 2017-09-25 10:35:34 +0200 | [diff] [blame] | 88 | #define LOGPPDP(level, pdp, fmt, args...) LOGPDPX(DGGSN, level, pdp, fmt, ## args) |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 89 | |
| 90 | static int ggsn_tun_fd_cb(struct osmo_fd *fd, unsigned int what); |
| 91 | static int cb_tun_ind(struct tun_t *tun, void *pack, unsigned len); |
| 92 | |
| 93 | |
| 94 | static void pool_close_all_pdp(struct ippool_t *pool) |
Harald Welte | bed35df | 2011-11-02 13:06:18 +0100 | [diff] [blame] | 95 | { |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 96 | unsigned int i; |
jjako | 52c2414 | 2002-12-16 13:33:51 +0000 | [diff] [blame] | 97 | |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 98 | if (!pool) |
Harald Welte | bed35df | 2011-11-02 13:06:18 +0100 | [diff] [blame] | 99 | return; |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 100 | |
| 101 | for (i = 0; i < pool->listsize; i++) { |
| 102 | struct ippoolm_t *member = &pool->member[i]; |
| 103 | struct pdp_t *pdp; |
| 104 | |
| 105 | if (!member->inuse) |
| 106 | continue; |
| 107 | pdp = member->peer; |
| 108 | if (!pdp) |
| 109 | continue; |
| 110 | LOGPPDP(LOGL_DEBUG, pdp, "Sending DELETE PDP CTX due to shutdown\n"); |
Oliver Smith | 1cde2c1 | 2019-05-13 11:35:03 +0200 | [diff] [blame] | 111 | gtp_delete_context_req2(pdp->gsn, pdp, NULL, 1); |
| 112 | /* We have nothing more to do with pdp ctx, free it. Upon cb_delete_context |
| 113 | called during this call we'll clean up ggsn related stuff attached to this |
| 114 | pdp context. After this call, ippool member is cleared so |
| 115 | data is no longer valid and should not be accessed anymore. */ |
| 116 | gtp_freepdp_teardown(pdp->gsn, pdp); |
Harald Welte | bed35df | 2011-11-02 13:06:18 +0100 | [diff] [blame] | 117 | } |
jjako | 52c2414 | 2002-12-16 13:33:51 +0000 | [diff] [blame] | 118 | } |
| 119 | |
Pau Espin Pedrol | 72ab4bc | 2019-05-29 19:08:26 +0200 | [diff] [blame] | 120 | int apn_stop(struct apn_ctx *apn) |
Harald Welte | bed35df | 2011-11-02 13:06:18 +0100 | [diff] [blame] | 121 | { |
Pau Espin Pedrol | 72ab4bc | 2019-05-29 19:08:26 +0200 | [diff] [blame] | 122 | LOGPAPN(LOGL_NOTICE, apn, "Stopping\n"); |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 123 | /* check if pools have any active PDP contexts and bail out */ |
| 124 | pool_close_all_pdp(apn->v4.pool); |
| 125 | pool_close_all_pdp(apn->v6.pool); |
| 126 | |
| 127 | /* shutdown whatever old state might be left */ |
| 128 | if (apn->tun.tun) { |
| 129 | /* run ip-down script */ |
| 130 | if (apn->tun.cfg.ipdown_script) { |
| 131 | LOGPAPN( LOGL_INFO, apn, "Running %s\n", apn->tun.cfg.ipdown_script); |
| 132 | tun_runscript(apn->tun.tun, apn->tun.cfg.ipdown_script); |
| 133 | } |
Harald Welte | f228639 | 2018-04-25 19:02:31 +0200 | [diff] [blame] | 134 | if (apn->cfg.gtpu_mode == APN_GTPU_MODE_TUN) { |
| 135 | /* release tun device */ |
| 136 | LOGPAPN(LOGL_INFO, apn, "Closing TUN device %s\n", apn->tun.tun->devname); |
| 137 | osmo_fd_unregister(&apn->tun.fd); |
| 138 | } |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 139 | tun_free(apn->tun.tun); |
| 140 | apn->tun.tun = NULL; |
| 141 | } |
| 142 | |
| 143 | if (apn->v4.pool) { |
| 144 | LOGPAPN(LOGL_INFO, apn, "Releasing IPv4 pool\n"); |
| 145 | ippool_free(apn->v4.pool); |
| 146 | apn->v4.pool = NULL; |
| 147 | } |
| 148 | if (apn->v6.pool) { |
| 149 | LOGPAPN(LOGL_INFO, apn, "Releasing IPv6 pool\n"); |
| 150 | ippool_free(apn->v6.pool); |
| 151 | apn->v6.pool = NULL; |
| 152 | } |
| 153 | |
| 154 | apn->started = false; |
| 155 | return 0; |
| 156 | } |
| 157 | |
Pau Espin Pedrol | 859f9b0 | 2017-10-16 14:52:25 +0200 | [diff] [blame] | 158 | |
Harald Welte | f55a039 | 2017-11-08 14:33:55 +0900 | [diff] [blame] | 159 | static int alloc_ippool_blacklist(struct apn_ctx *apn, struct in46_prefix **blacklist, bool ipv6) |
Pau Espin Pedrol | 859f9b0 | 2017-10-16 14:52:25 +0200 | [diff] [blame] | 160 | { |
| 161 | |
| 162 | int flags, len, len2, i; |
| 163 | |
Harald Welte | e2a1de5 | 2017-11-08 15:24:07 +0900 | [diff] [blame] | 164 | *blacklist = NULL; |
| 165 | |
Pau Espin Pedrol | 859f9b0 | 2017-10-16 14:52:25 +0200 | [diff] [blame] | 166 | if (ipv6) |
| 167 | flags = IP_TYPE_IPv6_NONLINK; |
| 168 | else |
| 169 | flags = IP_TYPE_IPv4; |
| 170 | |
| 171 | while (1) { |
Harald Welte | e2a1de5 | 2017-11-08 15:24:07 +0900 | [diff] [blame] | 172 | len = netdev_ip_local_get(apn->tun.cfg.dev_name, NULL, 0, flags); |
Pau Espin Pedrol | 859f9b0 | 2017-10-16 14:52:25 +0200 | [diff] [blame] | 173 | if (len < 1) |
| 174 | return len; |
| 175 | |
| 176 | *blacklist = talloc_zero_size(apn, len * sizeof(struct in46_prefix)); |
Harald Welte | e2a1de5 | 2017-11-08 15:24:07 +0900 | [diff] [blame] | 177 | len2 = netdev_ip_local_get(apn->tun.cfg.dev_name, *blacklist, len, flags); |
Pau Espin Pedrol | 859f9b0 | 2017-10-16 14:52:25 +0200 | [diff] [blame] | 178 | if (len2 < 1) { |
| 179 | talloc_free(*blacklist); |
Harald Welte | e2a1de5 | 2017-11-08 15:24:07 +0900 | [diff] [blame] | 180 | *blacklist = NULL; |
Pau Espin Pedrol | 859f9b0 | 2017-10-16 14:52:25 +0200 | [diff] [blame] | 181 | return len2; |
| 182 | } |
| 183 | |
Harald Welte | e2a1de5 | 2017-11-08 15:24:07 +0900 | [diff] [blame] | 184 | if (len2 > len) { /* iface was added between 2 calls, repeat operation */ |
Pau Espin Pedrol | 859f9b0 | 2017-10-16 14:52:25 +0200 | [diff] [blame] | 185 | talloc_free(*blacklist); |
Harald Welte | e2a1de5 | 2017-11-08 15:24:07 +0900 | [diff] [blame] | 186 | *blacklist = NULL; |
| 187 | } else |
Pau Espin Pedrol | 859f9b0 | 2017-10-16 14:52:25 +0200 | [diff] [blame] | 188 | break; |
| 189 | } |
| 190 | |
| 191 | for (i = 0; i < len2; i++) |
| 192 | LOGPAPN(LOGL_INFO, apn, "Blacklist tun IP %s\n", |
| 193 | in46p_ntoa(&(*blacklist)[i])); |
| 194 | |
| 195 | return len2; |
| 196 | } |
| 197 | |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 198 | /* actually start the APN with its current config */ |
| 199 | int apn_start(struct apn_ctx *apn) |
| 200 | { |
Pau Espin Pedrol | 859f9b0 | 2017-10-16 14:52:25 +0200 | [diff] [blame] | 201 | int ippool_flags = IPPOOL_NONETWORK | IPPOOL_NOBROADCAST; |
Pau Espin Pedrol | a037e59 | 2017-10-16 14:41:37 +0200 | [diff] [blame] | 202 | struct in46_prefix ipv6_tun_linklocal_ip; |
Pau Espin Pedrol | 859f9b0 | 2017-10-16 14:52:25 +0200 | [diff] [blame] | 203 | struct in46_prefix *blacklist; |
| 204 | int blacklist_size; |
Harald Welte | f228639 | 2018-04-25 19:02:31 +0200 | [diff] [blame] | 205 | struct gsn_t *gsn = apn->ggsn->gsn; |
Pau Espin Pedrol | bffc3f9 | 2017-12-14 11:19:10 +0100 | [diff] [blame] | 206 | int rc; |
Pau Espin Pedrol | 859f9b0 | 2017-10-16 14:52:25 +0200 | [diff] [blame] | 207 | |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 208 | if (apn->started) |
| 209 | return 0; |
| 210 | |
| 211 | LOGPAPN(LOGL_INFO, apn, "Starting\n"); |
| 212 | switch (apn->cfg.gtpu_mode) { |
| 213 | case APN_GTPU_MODE_TUN: |
| 214 | LOGPAPN(LOGL_INFO, apn, "Opening TUN device %s\n", apn->tun.cfg.dev_name); |
Harald Welte | f228639 | 2018-04-25 19:02:31 +0200 | [diff] [blame] | 215 | if (tun_new(&apn->tun.tun, apn->tun.cfg.dev_name, false, -1, -1)) { |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 216 | LOGPAPN(LOGL_ERROR, apn, "Failed to configure tun device\n"); |
| 217 | return -1; |
| 218 | } |
| 219 | LOGPAPN(LOGL_INFO, apn, "Opened TUN device %s\n", apn->tun.tun->devname); |
| 220 | |
| 221 | /* Register with libosmcoore */ |
| 222 | osmo_fd_setup(&apn->tun.fd, apn->tun.tun->fd, BSC_FD_READ, ggsn_tun_fd_cb, apn, 0); |
| 223 | osmo_fd_register(&apn->tun.fd); |
| 224 | |
| 225 | /* Set TUN library callback */ |
| 226 | tun_set_cb_ind(apn->tun.tun, cb_tun_ind); |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 227 | break; |
| 228 | case APN_GTPU_MODE_KERNEL_GTP: |
Harald Welte | 2fc2bc6 | 2017-11-08 15:50:53 +0900 | [diff] [blame] | 229 | LOGPAPN(LOGL_INFO, apn, "Opening Kernel GTP device %s\n", apn->tun.cfg.dev_name); |
Harald Welte | 490782d | 2017-11-08 14:09:51 +0900 | [diff] [blame] | 230 | if (apn->cfg.apn_type_mask & (APN_TYPE_IPv6|APN_TYPE_IPv4v6)) { |
| 231 | LOGPAPN(LOGL_ERROR, apn, "Kernel GTP currently supports only IPv4\n"); |
Pau Espin Pedrol | 72ab4bc | 2019-05-29 19:08:26 +0200 | [diff] [blame] | 232 | apn_stop(apn); |
Harald Welte | 490782d | 2017-11-08 14:09:51 +0900 | [diff] [blame] | 233 | return -1; |
| 234 | } |
Harald Welte | f228639 | 2018-04-25 19:02:31 +0200 | [diff] [blame] | 235 | if (gsn == NULL) { |
Harald Welte | 0757504 | 2018-02-14 01:04:04 +0100 | [diff] [blame] | 236 | /* skip bringing up the APN now if the GSN is not initialized yet. |
| 237 | * This happens during initial load of the config file, as the |
| 238 | * "no shutdown" in the ggsn node only happens after the "apn" nodes |
| 239 | * are brought up */ |
| 240 | LOGPAPN(LOGL_NOTICE, apn, "Skipping APN start\n"); |
| 241 | return 0; |
| 242 | } |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 243 | /* use GTP kernel module for data packet encapsulation */ |
Harald Welte | f228639 | 2018-04-25 19:02:31 +0200 | [diff] [blame] | 244 | if (tun_new(&apn->tun.tun, apn->tun.cfg.dev_name, true, gsn->fd0, gsn->fd1u)) { |
| 245 | LOGPAPN(LOGL_ERROR, apn, "Failed to configure Kernel GTP device\n"); |
Harald Welte | 490782d | 2017-11-08 14:09:51 +0900 | [diff] [blame] | 246 | return -1; |
| 247 | } |
Harald Welte | bed35df | 2011-11-02 13:06:18 +0100 | [diff] [blame] | 248 | break; |
| 249 | default: |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 250 | LOGPAPN(LOGL_ERROR, apn, "Unknown GTPU Mode %d\n", apn->cfg.gtpu_mode); |
| 251 | return -1; |
Harald Welte | bed35df | 2011-11-02 13:06:18 +0100 | [diff] [blame] | 252 | } |
jjako | 0141d20 | 2004-01-09 15:19:20 +0000 | [diff] [blame] | 253 | |
Harald Welte | f228639 | 2018-04-25 19:02:31 +0200 | [diff] [blame] | 254 | /* common initialization below */ |
| 255 | |
| 256 | /* set back-pointer from TUN device to APN */ |
| 257 | apn->tun.tun->priv = apn; |
| 258 | |
| 259 | if (apn->v4.cfg.ifconfig_prefix.addr.len) { |
| 260 | LOGPAPN(LOGL_INFO, apn, "Setting tun IP address %s\n", |
| 261 | in46p_ntoa(&apn->v4.cfg.ifconfig_prefix)); |
| 262 | if (tun_addaddr(apn->tun.tun, &apn->v4.cfg.ifconfig_prefix.addr, NULL, |
| 263 | apn->v4.cfg.ifconfig_prefix.prefixlen)) { |
| 264 | LOGPAPN(LOGL_ERROR, apn, "Failed to set tun IPv4 address %s: %s\n", |
| 265 | in46p_ntoa(&apn->v4.cfg.ifconfig_prefix), strerror(errno)); |
Pau Espin Pedrol | 72ab4bc | 2019-05-29 19:08:26 +0200 | [diff] [blame] | 266 | apn_stop(apn); |
Harald Welte | f228639 | 2018-04-25 19:02:31 +0200 | [diff] [blame] | 267 | return -1; |
| 268 | } |
| 269 | } |
| 270 | |
| 271 | if (apn->v6.cfg.ifconfig_prefix.addr.len) { |
| 272 | LOGPAPN(LOGL_INFO, apn, "Setting tun IPv6 address %s\n", |
| 273 | in46p_ntoa(&apn->v6.cfg.ifconfig_prefix)); |
| 274 | if (tun_addaddr(apn->tun.tun, &apn->v6.cfg.ifconfig_prefix.addr, NULL, |
| 275 | apn->v6.cfg.ifconfig_prefix.prefixlen)) { |
| 276 | LOGPAPN(LOGL_ERROR, apn, "Failed to set tun IPv6 address %s: %s. " |
| 277 | "Ensure you have ipv6 support and not used the disable_ipv6 sysctl?\n", |
| 278 | in46p_ntoa(&apn->v6.cfg.ifconfig_prefix), strerror(errno)); |
Pau Espin Pedrol | 72ab4bc | 2019-05-29 19:08:26 +0200 | [diff] [blame] | 279 | apn_stop(apn); |
Harald Welte | f228639 | 2018-04-25 19:02:31 +0200 | [diff] [blame] | 280 | return -1; |
| 281 | } |
| 282 | } |
| 283 | |
| 284 | if (apn->v6.cfg.ll_prefix.addr.len) { |
| 285 | LOGPAPN(LOGL_INFO, apn, "Setting tun IPv6 link-local address %s\n", |
| 286 | in46p_ntoa(&apn->v6.cfg.ll_prefix)); |
| 287 | if (tun_addaddr(apn->tun.tun, &apn->v6.cfg.ll_prefix.addr, NULL, |
| 288 | apn->v6.cfg.ll_prefix.prefixlen)) { |
| 289 | LOGPAPN(LOGL_ERROR, apn, "Failed to set tun IPv6 link-local address %s: %s. " |
| 290 | "Ensure you have ipv6 support and not used the disable_ipv6 sysctl?\n", |
| 291 | in46p_ntoa(&apn->v6.cfg.ll_prefix), strerror(errno)); |
Pau Espin Pedrol | 72ab4bc | 2019-05-29 19:08:26 +0200 | [diff] [blame] | 292 | apn_stop(apn); |
Harald Welte | f228639 | 2018-04-25 19:02:31 +0200 | [diff] [blame] | 293 | return -1; |
| 294 | } |
| 295 | apn->v6_lladdr = apn->v6.cfg.ll_prefix.addr.v6; |
| 296 | } |
| 297 | |
| 298 | if (apn->tun.cfg.ipup_script) { |
| 299 | LOGPAPN(LOGL_INFO, apn, "Running ip-up script %s\n", |
| 300 | apn->tun.cfg.ipup_script); |
| 301 | tun_runscript(apn->tun.tun, apn->tun.cfg.ipup_script); |
| 302 | } |
| 303 | |
| 304 | if (apn->cfg.apn_type_mask & (APN_TYPE_IPv6|APN_TYPE_IPv4v6) && |
| 305 | apn->v6.cfg.ll_prefix.addr.len == 0) { |
| 306 | rc = tun_ip_local_get(apn->tun.tun, &ipv6_tun_linklocal_ip, 1, IP_TYPE_IPv6_LINK); |
| 307 | if (rc < 1) { |
| 308 | LOGPAPN(LOGL_ERROR, apn, "Cannot obtain IPv6 link-local address of interface: %s\n", |
| 309 | rc ? strerror(errno) : "tun interface has no link-local IP assigned"); |
Pau Espin Pedrol | 72ab4bc | 2019-05-29 19:08:26 +0200 | [diff] [blame] | 310 | apn_stop(apn); |
Harald Welte | f228639 | 2018-04-25 19:02:31 +0200 | [diff] [blame] | 311 | return -1; |
| 312 | } |
| 313 | apn->v6_lladdr = ipv6_tun_linklocal_ip.addr.v6; |
| 314 | } |
| 315 | |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 316 | /* Create IPv4 pool */ |
| 317 | if (apn->v4.cfg.dynamic_prefix.addr.len) { |
| 318 | LOGPAPN(LOGL_INFO, apn, "Creating IPv4 pool %s\n", |
| 319 | in46p_ntoa(&apn->v4.cfg.dynamic_prefix)); |
Harald Welte | f55a039 | 2017-11-08 14:33:55 +0900 | [diff] [blame] | 320 | if ((blacklist_size = alloc_ippool_blacklist(apn, &blacklist, false)) < 0) |
Pau Espin Pedrol | 859f9b0 | 2017-10-16 14:52:25 +0200 | [diff] [blame] | 321 | LOGPAPN(LOGL_ERROR, apn, "Failed obtaining IPv4 tun IPs\n"); |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 322 | if (ippool_new(&apn->v4.pool, &apn->v4.cfg.dynamic_prefix, |
Pau Espin Pedrol | 859f9b0 | 2017-10-16 14:52:25 +0200 | [diff] [blame] | 323 | &apn->v4.cfg.static_prefix, ippool_flags, |
| 324 | blacklist, blacklist_size)) { |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 325 | LOGPAPN(LOGL_ERROR, apn, "Failed to create IPv4 pool\n"); |
Pau Espin Pedrol | 859f9b0 | 2017-10-16 14:52:25 +0200 | [diff] [blame] | 326 | talloc_free(blacklist); |
Pau Espin Pedrol | 72ab4bc | 2019-05-29 19:08:26 +0200 | [diff] [blame] | 327 | apn_stop(apn); |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 328 | return -1; |
| 329 | } |
Pau Espin Pedrol | 859f9b0 | 2017-10-16 14:52:25 +0200 | [diff] [blame] | 330 | talloc_free(blacklist); |
Harald Welte | bed35df | 2011-11-02 13:06:18 +0100 | [diff] [blame] | 331 | } |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 332 | |
| 333 | /* Create IPv6 pool */ |
| 334 | if (apn->v6.cfg.dynamic_prefix.addr.len) { |
| 335 | LOGPAPN(LOGL_INFO, apn, "Creating IPv6 pool %s\n", |
| 336 | in46p_ntoa(&apn->v6.cfg.dynamic_prefix)); |
Harald Welte | f55a039 | 2017-11-08 14:33:55 +0900 | [diff] [blame] | 337 | if ((blacklist_size = alloc_ippool_blacklist(apn, &blacklist, true)) < 0) |
Pau Espin Pedrol | 859f9b0 | 2017-10-16 14:52:25 +0200 | [diff] [blame] | 338 | LOGPAPN(LOGL_ERROR, apn, "Failed obtaining IPv6 tun IPs\n"); |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 339 | if (ippool_new(&apn->v6.pool, &apn->v6.cfg.dynamic_prefix, |
Pau Espin Pedrol | 859f9b0 | 2017-10-16 14:52:25 +0200 | [diff] [blame] | 340 | &apn->v6.cfg.static_prefix, ippool_flags, |
| 341 | blacklist, blacklist_size)) { |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 342 | LOGPAPN(LOGL_ERROR, apn, "Failed to create IPv6 pool\n"); |
Pau Espin Pedrol | 859f9b0 | 2017-10-16 14:52:25 +0200 | [diff] [blame] | 343 | talloc_free(blacklist); |
Pau Espin Pedrol | 72ab4bc | 2019-05-29 19:08:26 +0200 | [diff] [blame] | 344 | apn_stop(apn); |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 345 | return -1; |
| 346 | } |
Pau Espin Pedrol | 859f9b0 | 2017-10-16 14:52:25 +0200 | [diff] [blame] | 347 | talloc_free(blacklist); |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 348 | } |
| 349 | |
| 350 | LOGPAPN(LOGL_NOTICE, apn, "Successfully started\n"); |
| 351 | apn->started = true; |
| 352 | return 0; |
jjako | 0141d20 | 2004-01-09 15:19:20 +0000 | [diff] [blame] | 353 | } |
jjako | 0141d20 | 2004-01-09 15:19:20 +0000 | [diff] [blame] | 354 | |
Max | 3142d8d | 2017-05-04 17:45:10 +0200 | [diff] [blame] | 355 | static bool send_trap(const struct gsn_t *gsn, const struct pdp_t *pdp, const struct ippoolm_t *member, const char *var) |
| 356 | { |
Harald Welte | d12eab9 | 2017-08-02 19:49:47 +0200 | [diff] [blame] | 357 | char addrbuf[256]; |
Max | 3142d8d | 2017-05-04 17:45:10 +0200 | [diff] [blame] | 358 | char val[NAMESIZE]; |
| 359 | |
Harald Welte | d12eab9 | 2017-08-02 19:49:47 +0200 | [diff] [blame] | 360 | const char *addrstr = in46a_ntop(&member->addr, addrbuf, sizeof(addrbuf)); |
| 361 | |
Harald Welte | b10ee08 | 2017-08-12 19:29:16 +0200 | [diff] [blame] | 362 | snprintf(val, sizeof(val), "%s,%s", imsi_gtp2str(&pdp->imsi), addrstr); |
Max | 3142d8d | 2017-05-04 17:45:10 +0200 | [diff] [blame] | 363 | |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 364 | if (ctrl_cmd_send_trap(g_ctrlh, var, val) < 0) { |
| 365 | LOGPPDP(LOGL_ERROR, pdp, "Failed to create and send TRAP %s\n", var); |
Max | 3142d8d | 2017-05-04 17:45:10 +0200 | [diff] [blame] | 366 | return false; |
| 367 | } |
| 368 | return true; |
| 369 | } |
| 370 | |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 371 | static int delete_context(struct pdp_t *pdp) |
Harald Welte | bed35df | 2011-11-02 13:06:18 +0100 | [diff] [blame] | 372 | { |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 373 | struct gsn_t *gsn = pdp->gsn; |
Harald Welte | 698a233 | 2017-11-08 15:09:58 +0900 | [diff] [blame] | 374 | struct apn_ctx *apn = pdp->priv; |
Pau Espin Pedrol | 2d6a69e | 2017-12-06 19:26:25 +0100 | [diff] [blame] | 375 | struct ippoolm_t *member; |
| 376 | int i; |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 377 | |
| 378 | LOGPPDP(LOGL_INFO, pdp, "Deleting PDP context\n"); |
Max | dbd7024 | 2016-10-14 13:38:05 +0200 | [diff] [blame] | 379 | |
Pau Espin Pedrol | 2d6a69e | 2017-12-06 19:26:25 +0100 | [diff] [blame] | 380 | for (i = 0; i < 2; i++) { |
| 381 | if (pdp->peer[i]) { |
| 382 | member = pdp->peer[i]; |
| 383 | send_trap(gsn, pdp, member, "imsi-rem-ip"); /* TRAP with IP removal */ |
| 384 | ippool_freeip(member->pool, member); |
| 385 | } else if(i == 0) |
| 386 | LOGPPDP(LOGL_ERROR, pdp, "Cannot find/free IP Pool member\n"); |
| 387 | } |
Pablo Neira Ayuso | 4b075b6 | 2015-11-17 12:22:42 +0100 | [diff] [blame] | 388 | |
Harald Welte | 546884d | 2018-04-25 21:13:06 +0200 | [diff] [blame] | 389 | if (apn->cfg.gtpu_mode == APN_GTPU_MODE_KERNEL_GTP) { |
| 390 | if (gtp_kernel_tunnel_del(pdp, apn->tun.cfg.dev_name)) { |
| 391 | LOGPPDP(LOGL_ERROR, pdp, "Cannot delete tunnel from kernel:%s\n", |
| 392 | strerror(errno)); |
| 393 | } |
Pablo Neira Ayuso | 4b075b6 | 2015-11-17 12:22:42 +0100 | [diff] [blame] | 394 | } |
| 395 | |
Harald Welte | bed35df | 2011-11-02 13:06:18 +0100 | [diff] [blame] | 396 | return 0; |
jjako | 52c2414 | 2002-12-16 13:33:51 +0000 | [diff] [blame] | 397 | } |
| 398 | |
Harald Welte | 1ae9877 | 2017-08-09 20:28:52 +0200 | [diff] [blame] | 399 | #include <osmocom/gsm/tlv.h> |
| 400 | |
Pau Espin Pedrol | 0bdd8bf | 2018-01-26 17:46:37 +0100 | [diff] [blame] | 401 | /* RFC 1332 */ |
| 402 | enum ipcp_options { |
| 403 | IPCP_OPT_IPADDR = 3, |
| 404 | IPCP_OPT_PRIMARY_DNS = 129, |
| 405 | IPCP_OPT_SECONDARY_DNS = 131, |
| 406 | }; |
| 407 | |
| 408 | struct ipcp_option_hdr { |
| 409 | uint8_t type; |
| 410 | uint8_t len; |
| 411 | uint8_t data[0]; |
Philipp Maier | 6a2856b | 2018-05-28 17:50:09 +0200 | [diff] [blame] | 412 | } __attribute__ ((packed)); |
Pau Espin Pedrol | 0bdd8bf | 2018-01-26 17:46:37 +0100 | [diff] [blame] | 413 | |
| 414 | struct ipcp_hdr { |
| 415 | uint8_t code; |
| 416 | uint8_t id; |
| 417 | uint16_t len; |
| 418 | uint8_t options[0]; |
Philipp Maier | 6a2856b | 2018-05-28 17:50:09 +0200 | [diff] [blame] | 419 | } __attribute__ ((packed)); |
Pau Espin Pedrol | 0bdd8bf | 2018-01-26 17:46:37 +0100 | [diff] [blame] | 420 | |
| 421 | /* determine if IPCP contains given option */ |
Harald Welte | 42c9fa4 | 2019-04-10 15:19:04 +0200 | [diff] [blame] | 422 | static const uint8_t *ipcp_contains_option(const uint8_t *ipcp, size_t ipcp_len, |
| 423 | enum ipcp_options opt, size_t opt_minlen) |
Pau Espin Pedrol | 0bdd8bf | 2018-01-26 17:46:37 +0100 | [diff] [blame] | 424 | { |
Harald Welte | 42c9fa4 | 2019-04-10 15:19:04 +0200 | [diff] [blame] | 425 | const uint8_t *cur_opt = ipcp + sizeof(struct ipcp_hdr); |
Pau Espin Pedrol | 0bdd8bf | 2018-01-26 17:46:37 +0100 | [diff] [blame] | 426 | |
| 427 | /* iterate over Options and check if protocol contained */ |
Harald Welte | 549417e | 2019-04-10 15:26:08 +0200 | [diff] [blame] | 428 | while (cur_opt + sizeof(struct ipcp_option_hdr) <= ipcp + ipcp_len) { |
| 429 | const struct ipcp_option_hdr *cur_opt_hdr = (const struct ipcp_option_hdr *)cur_opt; |
| 430 | /* length value includes 2 bytes type/length */ |
| 431 | if (cur_opt_hdr->len < sizeof(struct ipcp_option_hdr)) |
Stefan Sperling | d70ab97 | 2018-07-19 15:25:47 +0200 | [diff] [blame] | 432 | return NULL; |
Harald Welte | 549417e | 2019-04-10 15:26:08 +0200 | [diff] [blame] | 433 | if (cur_opt_hdr->type == opt && |
| 434 | cur_opt_hdr->len >= sizeof(struct ipcp_option_hdr) + opt_minlen) |
Pau Espin Pedrol | 0bdd8bf | 2018-01-26 17:46:37 +0100 | [diff] [blame] | 435 | return cur_opt; |
Harald Welte | 549417e | 2019-04-10 15:26:08 +0200 | [diff] [blame] | 436 | cur_opt += cur_opt_hdr->len; |
Pau Espin Pedrol | 0bdd8bf | 2018-01-26 17:46:37 +0100 | [diff] [blame] | 437 | } |
| 438 | return NULL; |
| 439 | } |
| 440 | |
Harald Welte | 1ae9877 | 2017-08-09 20:28:52 +0200 | [diff] [blame] | 441 | /* 3GPP TS 24.008 10.6.5.3 */ |
| 442 | enum pco_protocols { |
| 443 | PCO_P_LCP = 0xC021, |
| 444 | PCO_P_PAP = 0xC023, |
| 445 | PCO_P_CHAP = 0xC223, |
| 446 | PCO_P_IPCP = 0x8021, |
| 447 | PCO_P_PCSCF_ADDR = 0x0001, |
| 448 | PCO_P_IM_CN_SS_F = 0x0002, |
| 449 | PCO_P_DNS_IPv6_ADDR = 0x0003, |
| 450 | PCO_P_POLICY_CTRL_REJ = 0x0004, /* only in Network->MS */ |
| 451 | PCO_P_MS_SUP_NETREQ_BCI = 0x0005, |
| 452 | /* reserved */ |
| 453 | PCO_P_DSMIPv6_HA_ADDR = 0x0007, |
| 454 | PCO_P_DSMIPv6_HN_PREF = 0x0008, |
| 455 | PCO_P_DSMIPv6_v4_HA_ADDR= 0x0009, |
| 456 | PCO_P_IP_ADDR_VIA_NAS = 0x000a, /* only MS->Network */ |
| 457 | PCO_P_IPv4_ADDR_VIA_DHCP= 0x000b, /* only MS->Netowrk */ |
| 458 | PCO_P_PCSCF_IPv4_ADDR = 0x000c, |
| 459 | PCO_P_DNS_IPv4_ADDR = 0x000d, |
| 460 | PCO_P_MSISDN = 0x000e, |
| 461 | PCO_P_IFOM_SUPPORT = 0x000f, |
| 462 | PCO_P_IPv4_LINK_MTU = 0x0010, |
| 463 | PCO_P_MS_SUPP_LOC_A_TFT = 0x0011, |
| 464 | PCO_P_PCSCF_RESEL_SUP = 0x0012, /* only MS->Network */ |
| 465 | PCO_P_NBIFOM_REQ = 0x0013, |
| 466 | PCO_P_NBIFOM_MODE = 0x0014, |
| 467 | PCO_P_NONIP_LINK_MTU = 0x0015, |
| 468 | PCO_P_APN_RATE_CTRL_SUP = 0x0016, |
| 469 | PCO_P_PS_DATA_OFF_UE = 0x0017, |
| 470 | PCO_P_REL_DATA_SVC = 0x0018, |
| 471 | }; |
| 472 | |
Harald Welte | df404c4 | 2019-04-10 15:15:26 +0200 | [diff] [blame] | 473 | struct pco_element { |
| 474 | uint16_t protocol_id; /* network byte order */ |
| 475 | uint8_t length; /* length of data below */ |
| 476 | uint8_t data[0]; |
| 477 | } __attribute__((packed)); |
| 478 | |
Pau Espin Pedrol | 7d54ed4 | 2018-01-25 20:09:16 +0100 | [diff] [blame] | 479 | /*! Get the peer of pdp based on IP version used. |
| 480 | * \param[in] pdp PDP context to select the peer from. |
| 481 | * \param[in] v4v6 IP version to select. Valid values are 4 and 6. |
| 482 | * \returns The selected peer matching the given IP version. NULL if not present. |
| 483 | */ |
| 484 | static struct ippoolm_t *pdp_get_peer_ipv(struct pdp_t *pdp, bool is_ipv6) { |
| 485 | uint8_t len1, len2, i; |
| 486 | |
| 487 | if (is_ipv6) { |
| 488 | len1 = 8; |
| 489 | len2 = 16; |
| 490 | } else { |
| 491 | len1 = sizeof(struct in_addr); |
| 492 | len2 = len1; |
| 493 | } |
| 494 | |
| 495 | for (i = 0; i < 2; i++) { |
| 496 | struct ippoolm_t * ippool = pdp->peer[i]; |
| 497 | if (ippool && (ippool->addr.len == len1 || ippool->addr.len == len2)) |
| 498 | return ippool; |
| 499 | } |
| 500 | return NULL; |
| 501 | } |
| 502 | |
Harald Welte | 7bdc80d | 2019-04-11 18:47:59 +0200 | [diff] [blame] | 503 | /* RFC 1334, section 3.2. Packet Format */ |
| 504 | struct pap_element { |
| 505 | uint8_t code; |
| 506 | uint8_t id; |
| 507 | uint16_t len; /* length including header */ |
| 508 | uint8_t data[0]; |
| 509 | } __attribute__((packed)); |
| 510 | |
| 511 | enum pap_code { |
| 512 | PAP_CODE_AUTH_REQ = 1, |
| 513 | PAP_CODE_AUTH_ACK = 2, |
| 514 | PAP_CODE_AUTH_NAK = 3, |
| 515 | }; |
| 516 | |
| 517 | static const char *pap_welcome = "Welcome to OsmoGGSN " PACKAGE_VERSION; |
| 518 | |
| 519 | /* Handle PAP protocol according to RFC 1334 */ |
| 520 | static void process_pco_element_pap(const struct pco_element *pco_in, struct msgb *resp, |
| 521 | const struct apn_ctx *apn, struct pdp_t *pdp) |
| 522 | { |
| 523 | const struct pap_element *pap_in = (const struct pap_element *) pco_in->data; |
| 524 | uint16_t pap_in_len; |
| 525 | uint8_t peer_id_len; |
| 526 | const uint8_t *peer_id; |
| 527 | unsigned int pap_welcome_len; |
| 528 | uint8_t pap_out_size; |
| 529 | struct pap_element *pap_out; |
| 530 | |
| 531 | if (pco_in->length < sizeof(struct pap_element)) |
| 532 | goto ret_broken; |
| 533 | |
| 534 | pap_in_len = osmo_load16be(&pap_in->len); |
| 535 | if (pco_in->length < pap_in_len) |
| 536 | goto ret_broken; |
| 537 | /* "pco_in->length > pap_in_len" is allowed: RFC1334 2.2 states: |
| 538 | "Octets outside the range of the Length field should be treated as |
| 539 | Data Link Layer padding and should be ignored on reception." |
| 540 | */ |
| 541 | |
| 542 | switch (pap_in->code) { |
| 543 | case PAP_CODE_AUTH_REQ: |
| 544 | if (pap_in_len < sizeof(struct pap_element) + 1) |
| 545 | goto ret_broken_auth; |
| 546 | peer_id_len = pap_in->data[0]; |
| 547 | if (pap_in_len < sizeof(struct pap_element) + 1 + peer_id_len) |
| 548 | goto ret_broken_auth; |
| 549 | peer_id = &pap_in->data[1]; |
| 550 | LOGPPDP(LOGL_DEBUG, pdp, "PCO PAP PeerId = %s, ACKing\n", |
| 551 | osmo_quote_str((const char *)peer_id, peer_id_len)); |
| 552 | /* Password-Length + Password following here, but we don't care */ |
| 553 | |
| 554 | /* Prepare response, we ACK all of them: */ |
| 555 | pap_welcome_len = strlen(pap_welcome); |
| 556 | /* +1: Length field of pap_welcome Message */ |
| 557 | pap_out_size = sizeof(struct pap_element) + 1 + pap_welcome_len; |
| 558 | pap_out = alloca(pap_out_size); |
| 559 | pap_out->code = PAP_CODE_AUTH_ACK; |
| 560 | pap_out->id = pap_in->id; |
| 561 | pap_out->len = htons(pap_out_size); |
| 562 | pap_out->data[0] = pap_welcome_len; |
| 563 | memcpy(pap_out->data+1, pap_welcome, pap_welcome_len); |
| 564 | msgb_t16lv_put(resp, PCO_P_PAP, pap_out_size, (uint8_t *) pap_out); |
| 565 | break; |
| 566 | case PAP_CODE_AUTH_ACK: |
| 567 | case PAP_CODE_AUTH_NAK: |
| 568 | default: |
| 569 | LOGPPDP(LOGL_NOTICE, pdp, "Unsupported PAP PCO Code %u, ignoring\n", pap_in->code); |
| 570 | break; |
| 571 | } |
| 572 | return; |
| 573 | |
| 574 | ret_broken_auth: |
| 575 | LOGPPDP(LOGL_NOTICE, pdp, "Invalid PAP AuthenticateReq: %s, ignoring\n", |
| 576 | osmo_hexdump_nospc((const uint8_t *)pco_in, pco_in->length)); |
| 577 | return; |
| 578 | |
| 579 | ret_broken: |
| 580 | LOGPPDP(LOGL_NOTICE, pdp, "Invalid PAP PCO Length: %s, ignoring\n", |
| 581 | osmo_hexdump_nospc((const uint8_t *)pco_in, pco_in->length)); |
| 582 | } |
| 583 | |
Harald Welte | 9272d21 | 2019-04-11 15:39:16 +0200 | [diff] [blame] | 584 | static void process_pco_element_ipcp(const struct pco_element *pco_elem, struct msgb *resp, |
| 585 | const struct apn_ctx *apn, struct pdp_t *pdp) |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 586 | { |
Harald Welte | 9272d21 | 2019-04-11 15:39:16 +0200 | [diff] [blame] | 587 | struct ippoolm_t *peer_v4 = pdp_get_peer_ipv(pdp, false); |
Pau Espin Pedrol | 0bdd8bf | 2018-01-26 17:46:37 +0100 | [diff] [blame] | 588 | const struct in46_addr *dns1 = &apn->v4.cfg.dns[0]; |
| 589 | const struct in46_addr *dns2 = &apn->v4.cfg.dns[1]; |
Harald Welte | 9272d21 | 2019-04-11 15:39:16 +0200 | [diff] [blame] | 590 | uint8_t *start = resp->tail; |
Harald Welte | f653c5b | 2019-04-10 15:48:26 +0200 | [diff] [blame] | 591 | const uint8_t *ipcp; |
Stefan Sperling | d70ab97 | 2018-07-19 15:25:47 +0200 | [diff] [blame] | 592 | uint16_t ipcp_len; |
Harald Welte | 42c9fa4 | 2019-04-10 15:19:04 +0200 | [diff] [blame] | 593 | uint8_t *len1, *len2; |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 594 | unsigned int len_appended; |
Stefan Sperling | d70ab97 | 2018-07-19 15:25:47 +0200 | [diff] [blame] | 595 | ptrdiff_t consumed; |
Harald Welte | 9272d21 | 2019-04-11 15:39:16 +0200 | [diff] [blame] | 596 | size_t remain; |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 597 | |
Harald Welte | 32b76ee | 2019-04-11 18:57:16 +0200 | [diff] [blame^] | 598 | if (!peer_v4) { |
| 599 | LOGPPDP(LOGL_ERROR, pdp, "IPCP but no IPv4 type ?!?\n"); |
Harald Welte | 9272d21 | 2019-04-11 15:39:16 +0200 | [diff] [blame] | 600 | return; |
Harald Welte | 32b76ee | 2019-04-11 18:57:16 +0200 | [diff] [blame^] | 601 | } |
Stefan Sperling | d70ab97 | 2018-07-19 15:25:47 +0200 | [diff] [blame] | 602 | |
Harald Welte | 9272d21 | 2019-04-11 15:39:16 +0200 | [diff] [blame] | 603 | ipcp = pco_elem->data; |
| 604 | consumed = (ipcp - &pdp->pco_req.v[0]); |
| 605 | remain = sizeof(pdp->pco_req.v) - consumed; |
| 606 | ipcp_len = osmo_load16be(ipcp + 2); /* 1=code + 1=id */ |
Harald Welte | 32b76ee | 2019-04-11 18:57:16 +0200 | [diff] [blame^] | 607 | if (remain < 0 || remain < ipcp_len) { |
| 608 | LOGPPDP(LOGL_ERROR, pdp, "Malformed IPCP, ignoring\n"); |
Harald Welte | 9272d21 | 2019-04-11 15:39:16 +0200 | [diff] [blame] | 609 | return; |
Harald Welte | 32b76ee | 2019-04-11 18:57:16 +0200 | [diff] [blame^] | 610 | } |
Pau Espin Pedrol | 0bdd8bf | 2018-01-26 17:46:37 +0100 | [diff] [blame] | 611 | |
Harald Welte | 9272d21 | 2019-04-11 15:39:16 +0200 | [diff] [blame] | 612 | /* Three byte T16L header */ |
| 613 | msgb_put_u16(resp, 0x8021); /* IPCP */ |
| 614 | len1 = msgb_put(resp, 1); /* Length of contents: delay */ |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 615 | |
Harald Welte | 9272d21 | 2019-04-11 15:39:16 +0200 | [diff] [blame] | 616 | msgb_put_u8(resp, 0x02); /* ACK */ |
| 617 | msgb_put_u8(resp, ipcp[1]); /* ID: Needs to match request */ |
| 618 | msgb_put_u8(resp, 0x00); /* Length MSB */ |
| 619 | len2 = msgb_put(resp, 1); /* Length LSB: delay */ |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 620 | |
Harald Welte | 9272d21 | 2019-04-11 15:39:16 +0200 | [diff] [blame] | 621 | if (dns1->len == 4 && ipcp_contains_option(ipcp, ipcp_len, IPCP_OPT_PRIMARY_DNS, 4)) { |
| 622 | msgb_put_u8(resp, 0x81); /* DNS1 Tag */ |
| 623 | msgb_put_u8(resp, 2 + dns1->len); /* DNS1 Length, incl. TL */ |
| 624 | msgb_put_u32(resp, ntohl(dns1->v4.s_addr)); |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 625 | } |
| 626 | |
Harald Welte | 9272d21 | 2019-04-11 15:39:16 +0200 | [diff] [blame] | 627 | if (dns2->len == 4 && ipcp_contains_option(ipcp, ipcp_len, IPCP_OPT_SECONDARY_DNS, 4)) { |
| 628 | msgb_put_u8(resp, 0x83); /* DNS2 Tag */ |
| 629 | msgb_put_u8(resp, 2 + dns2->len); /* DNS2 Length, incl. TL */ |
| 630 | msgb_put_u32(resp, ntohl(dns2->v4.s_addr)); |
| 631 | } |
| 632 | |
| 633 | /* patch in length values */ |
| 634 | len_appended = resp->tail - start; |
| 635 | *len1 = len_appended - 3; |
| 636 | *len2 = len_appended - 3; |
| 637 | } |
| 638 | |
| 639 | static void process_pco_element_dns_ipv6(const struct pco_element *pco_elem, struct msgb *resp, |
| 640 | const struct apn_ctx *apn, struct pdp_t *pdp) |
| 641 | { |
| 642 | unsigned int i; |
Harald Welte | 32b76ee | 2019-04-11 18:57:16 +0200 | [diff] [blame^] | 643 | const uint8_t *tail = resp->tail; |
Harald Welte | 9272d21 | 2019-04-11 15:39:16 +0200 | [diff] [blame] | 644 | |
| 645 | for (i = 0; i < ARRAY_SIZE(apn->v6.cfg.dns); i++) { |
| 646 | const struct in46_addr *i46a = &apn->v6.cfg.dns[i]; |
| 647 | if (i46a->len != 16) |
| 648 | continue; |
| 649 | msgb_t16lv_put(resp, PCO_P_DNS_IPv6_ADDR, i46a->len, i46a->v6.s6_addr); |
| 650 | } |
Harald Welte | 32b76ee | 2019-04-11 18:57:16 +0200 | [diff] [blame^] | 651 | if (resp->tail == tail) |
| 652 | LOGPPDP(LOGL_NOTICE, pdp, "MS requested IPv6 DNS, but APN has none configured\n"); |
Harald Welte | 9272d21 | 2019-04-11 15:39:16 +0200 | [diff] [blame] | 653 | } |
| 654 | |
| 655 | static void process_pco_element_dns_ipv4(const struct pco_element *pco_elem, struct msgb *resp, |
| 656 | const struct apn_ctx *apn, struct pdp_t *pdp) |
| 657 | { |
| 658 | unsigned int i; |
Harald Welte | 32b76ee | 2019-04-11 18:57:16 +0200 | [diff] [blame^] | 659 | const uint8_t *tail = resp->tail; |
Harald Welte | 9272d21 | 2019-04-11 15:39:16 +0200 | [diff] [blame] | 660 | |
| 661 | for (i = 0; i < ARRAY_SIZE(apn->v4.cfg.dns); i++) { |
| 662 | const struct in46_addr *i46a = &apn->v4.cfg.dns[i]; |
| 663 | if (i46a->len != 4) |
| 664 | continue; |
| 665 | msgb_t16lv_put(resp, PCO_P_DNS_IPv4_ADDR, i46a->len, (uint8_t *)&i46a->v4); |
| 666 | } |
Harald Welte | 32b76ee | 2019-04-11 18:57:16 +0200 | [diff] [blame^] | 667 | if (resp->tail == tail) |
| 668 | LOGPPDP(LOGL_NOTICE, pdp, "MS requested IPv4 DNS, but APN has none configured\n"); |
Harald Welte | 9272d21 | 2019-04-11 15:39:16 +0200 | [diff] [blame] | 669 | } |
| 670 | |
| 671 | static void process_pco_element(const struct pco_element *pco_elem, struct msgb *resp, |
| 672 | const struct apn_ctx *apn, struct pdp_t *pdp) |
| 673 | { |
Harald Welte | 32b76ee | 2019-04-11 18:57:16 +0200 | [diff] [blame^] | 674 | uint16_t protocol_id = ntohs(pco_elem->protocol_id); |
| 675 | |
| 676 | LOGPPDP(LOGL_DEBUG, pdp, "PCO Protocol 0x%04x\n", protocol_id); |
| 677 | switch (protocol_id) { |
Harald Welte | 7bdc80d | 2019-04-11 18:47:59 +0200 | [diff] [blame] | 678 | case PCO_P_PAP: |
| 679 | process_pco_element_pap(pco_elem, resp, apn, pdp); |
| 680 | break; |
Harald Welte | 9272d21 | 2019-04-11 15:39:16 +0200 | [diff] [blame] | 681 | case PCO_P_IPCP: |
| 682 | process_pco_element_ipcp(pco_elem, resp, apn, pdp); |
| 683 | break; |
| 684 | case PCO_P_DNS_IPv6_ADDR: |
| 685 | process_pco_element_dns_ipv6(pco_elem, resp, apn, pdp); |
| 686 | break; |
| 687 | case PCO_P_DNS_IPv4_ADDR: |
| 688 | process_pco_element_dns_ipv4(pco_elem, resp, apn, pdp); |
| 689 | break; |
| 690 | default: |
Harald Welte | 32b76ee | 2019-04-11 18:57:16 +0200 | [diff] [blame^] | 691 | LOGPPDP(LOGL_INFO, pdp, "Unknown/Unimplemented PCO Protocol 0x%04x: %s\n", |
| 692 | protocol_id, osmo_hexdump_nospc(pco_elem->data, pco_elem->length)); |
Harald Welte | 9272d21 | 2019-04-11 15:39:16 +0200 | [diff] [blame] | 693 | break; |
| 694 | } |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 695 | } |
| 696 | |
Harald Welte | 1ae9877 | 2017-08-09 20:28:52 +0200 | [diff] [blame] | 697 | /* process one PCO request from a MS/UE, putting together the proper responses */ |
Harald Welte | ffa2273 | 2019-04-10 14:30:21 +0200 | [diff] [blame] | 698 | static void process_pco(const struct apn_ctx *apn, struct pdp_t *pdp) |
Harald Welte | 1ae9877 | 2017-08-09 20:28:52 +0200 | [diff] [blame] | 699 | { |
Harald Welte | 9272d21 | 2019-04-11 15:39:16 +0200 | [diff] [blame] | 700 | struct msgb *resp = msgb_alloc(256, "PCO.resp"); |
| 701 | const struct ul255_t *pco = &pdp->pco_req; |
| 702 | const struct pco_element *pco_elem; |
| 703 | const uint8_t *cur; |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 704 | |
Harald Welte | 9272d21 | 2019-04-11 15:39:16 +0200 | [diff] [blame] | 705 | /* build the header of the PCO response */ |
| 706 | OSMO_ASSERT(resp); |
| 707 | msgb_put_u8(resp, 0x80); /* ext-bit + configuration protocol byte */ |
Harald Welte | 1ae9877 | 2017-08-09 20:28:52 +0200 | [diff] [blame] | 708 | |
Harald Welte | 9272d21 | 2019-04-11 15:39:16 +0200 | [diff] [blame] | 709 | /* iterate over the PCO elements in the request; call process_pco_element() for each */ |
| 710 | for (cur = pco->v + 1, pco_elem = (const struct pco_element *) cur; |
| 711 | cur + sizeof(struct pco_element) <= pco->v + pco->l; |
| 712 | cur += pco_elem->length + sizeof(*pco_elem), pco_elem = (const struct pco_element *) cur) { |
| 713 | process_pco_element(pco_elem, resp, apn, pdp); |
Harald Welte | 1ae9877 | 2017-08-09 20:28:52 +0200 | [diff] [blame] | 714 | } |
| 715 | |
Harald Welte | 9272d21 | 2019-04-11 15:39:16 +0200 | [diff] [blame] | 716 | /* copy the PCO response msgb and copy its contents over to the PDP context */ |
| 717 | if (msgb_length(resp) > 1) { |
| 718 | memcpy(pdp->pco_neg.v, msgb_data(resp), msgb_length(resp)); |
| 719 | pdp->pco_neg.l = msgb_length(resp); |
Harald Welte | 1ae9877 | 2017-08-09 20:28:52 +0200 | [diff] [blame] | 720 | } else |
| 721 | pdp->pco_neg.l = 0; |
Harald Welte | 9272d21 | 2019-04-11 15:39:16 +0200 | [diff] [blame] | 722 | msgb_free(resp); |
Harald Welte | 1ae9877 | 2017-08-09 20:28:52 +0200 | [diff] [blame] | 723 | } |
| 724 | |
Harald Welte | 9d9d91b | 2017-10-14 16:22:16 +0200 | [diff] [blame] | 725 | static bool apn_supports_ipv4(const struct apn_ctx *apn) |
| 726 | { |
| 727 | if (apn->v4.cfg.static_prefix.addr.len || apn->v4.cfg.dynamic_prefix.addr.len) |
| 728 | return true; |
| 729 | return false; |
| 730 | } |
| 731 | |
| 732 | static bool apn_supports_ipv6(const struct apn_ctx *apn) |
| 733 | { |
| 734 | if (apn->v6.cfg.static_prefix.addr.len || apn->v6.cfg.dynamic_prefix.addr.len) |
| 735 | return true; |
| 736 | return false; |
| 737 | } |
| 738 | |
Harald Welte | bed35df | 2011-11-02 13:06:18 +0100 | [diff] [blame] | 739 | int create_context_ind(struct pdp_t *pdp) |
| 740 | { |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 741 | static char name_buf[256]; |
| 742 | struct gsn_t *gsn = pdp->gsn; |
| 743 | struct ggsn_ctx *ggsn = gsn->priv; |
Pau Espin Pedrol | 2d6a69e | 2017-12-06 19:26:25 +0100 | [diff] [blame] | 744 | struct in46_addr addr[2]; |
Pau Espin Pedrol | 4e43ef5 | 2018-01-26 18:12:19 +0100 | [diff] [blame] | 745 | struct ippoolm_t *member = NULL, *addrv4 = NULL, *addrv6 = NULL; |
| 746 | char straddrv4[INET_ADDRSTRLEN], straddrv6[INET6_ADDRSTRLEN]; |
Vadim Yanitskiy | 2e8e57a | 2019-05-13 22:09:15 +0700 | [diff] [blame] | 747 | struct apn_ctx *apn = NULL; |
Pau Espin Pedrol | 2d6a69e | 2017-12-06 19:26:25 +0100 | [diff] [blame] | 748 | int rc, num_addr, i; |
Vadim Yanitskiy | 2e8e57a | 2019-05-13 22:09:15 +0700 | [diff] [blame] | 749 | char *apn_name; |
jjako | 52c2414 | 2002-12-16 13:33:51 +0000 | [diff] [blame] | 750 | |
Vadim Yanitskiy | 2e8e57a | 2019-05-13 22:09:15 +0700 | [diff] [blame] | 751 | apn_name = osmo_apn_to_str(name_buf, pdp->apn_req.v, pdp->apn_req.l); |
| 752 | LOGPPDP(LOGL_DEBUG, pdp, "Processing create PDP context request for APN '%s'\n", |
| 753 | apn_name ? name_buf : "(NONE)"); |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 754 | |
| 755 | /* First find an exact APN name match */ |
Vadim Yanitskiy | 2e8e57a | 2019-05-13 22:09:15 +0700 | [diff] [blame] | 756 | if (apn_name != NULL) |
| 757 | apn = ggsn_find_apn(ggsn, name_buf); |
Harald Welte | 2e84d2c | 2017-10-01 13:36:52 +0800 | [diff] [blame] | 758 | /* ignore if the APN has not been started */ |
Pau Espin Pedrol | 958256f | 2017-10-11 20:32:55 +0200 | [diff] [blame] | 759 | if (apn && !apn->started) |
Harald Welte | 2e84d2c | 2017-10-01 13:36:52 +0800 | [diff] [blame] | 760 | apn = NULL; |
Harald Welte | b16c46b | 2017-10-01 18:28:18 +0800 | [diff] [blame] | 761 | |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 762 | /* then try default (if any) */ |
| 763 | if (!apn) |
| 764 | apn = ggsn->cfg.default_apn; |
Harald Welte | b16c46b | 2017-10-01 18:28:18 +0800 | [diff] [blame] | 765 | /* ignore if the APN has not been started */ |
Pau Espin Pedrol | 958256f | 2017-10-11 20:32:55 +0200 | [diff] [blame] | 766 | if (apn && !apn->started) |
Harald Welte | b16c46b | 2017-10-01 18:28:18 +0800 | [diff] [blame] | 767 | apn = NULL; |
| 768 | |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 769 | if (!apn) { |
| 770 | /* no APN found for what user requested */ |
| 771 | LOGPPDP(LOGL_NOTICE, pdp, "Unknown APN '%s', rejecting\n", name_buf); |
| 772 | gtp_create_context_resp(gsn, pdp, GTPCAUSE_MISSING_APN); |
| 773 | return 0; |
| 774 | } |
jjako | 52c2414 | 2002-12-16 13:33:51 +0000 | [diff] [blame] | 775 | |
Harald Welte | d9d8862 | 2017-08-04 00:22:35 +0200 | [diff] [blame] | 776 | /* FIXME: we manually force all context requests to dynamic here! */ |
| 777 | if (pdp->eua.l > 2) |
| 778 | pdp->eua.l = 2; |
jjako | 52c2414 | 2002-12-16 13:33:51 +0000 | [diff] [blame] | 779 | |
Harald Welte | bed35df | 2011-11-02 13:06:18 +0100 | [diff] [blame] | 780 | memcpy(pdp->qos_neg0, pdp->qos_req0, sizeof(pdp->qos_req0)); |
jjako | 52c2414 | 2002-12-16 13:33:51 +0000 | [diff] [blame] | 781 | |
Harald Welte | bed35df | 2011-11-02 13:06:18 +0100 | [diff] [blame] | 782 | memcpy(pdp->qos_neg.v, pdp->qos_req.v, pdp->qos_req.l); /* TODO */ |
| 783 | pdp->qos_neg.l = pdp->qos_req.l; |
jjako | 52c2414 | 2002-12-16 13:33:51 +0000 | [diff] [blame] | 784 | |
Pau Espin Pedrol | 2d6a69e | 2017-12-06 19:26:25 +0100 | [diff] [blame] | 785 | memset(addr, 0, sizeof(addr)); |
| 786 | if ((num_addr = in46a_from_eua(&pdp->eua, addr)) < 0) { |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 787 | LOGPPDP(LOGL_ERROR, pdp, "Cannot decode EUA from MS/SGSN: %s\n", |
Harald Welte | d1bf1e1 | 2017-08-03 00:00:23 +0200 | [diff] [blame] | 788 | osmo_hexdump(pdp->eua.v, pdp->eua.l)); |
| 789 | gtp_create_context_resp(gsn, pdp, GTPCAUSE_UNKNOWN_PDP); |
| 790 | return 0; |
Harald Welte | bed35df | 2011-11-02 13:06:18 +0100 | [diff] [blame] | 791 | } |
jjako | a7cd249 | 2003-04-11 09:40:12 +0000 | [diff] [blame] | 792 | |
Vadim Yanitskiy | d7030d2 | 2019-05-13 22:10:24 +0700 | [diff] [blame] | 793 | /* Store the actual APN for logging and the VTY */ |
| 794 | rc = osmo_apn_from_str(pdp->apn_use.v, sizeof(pdp->apn_use.v), apn->cfg.name); |
| 795 | if (rc < 0) /* Unlikely this would happen, but anyway... */ |
| 796 | LOGPPDP(LOGL_ERROR, pdp, "Failed to store APN '%s'\n", apn->cfg.name); |
| 797 | pdp->apn_use.l = rc; |
| 798 | |
Pau Espin Pedrol | 2d6a69e | 2017-12-06 19:26:25 +0100 | [diff] [blame] | 799 | /* Allocate dynamic addresses from the pool */ |
| 800 | for (i = 0; i < num_addr; i++) { |
| 801 | if (addr[i].len == sizeof(struct in_addr)) { |
| 802 | /* does this APN actually have an IPv4 pool? */ |
| 803 | if (!apn_supports_ipv4(apn)) |
| 804 | goto err_wrong_af; |
Harald Welte | 9d9d91b | 2017-10-14 16:22:16 +0200 | [diff] [blame] | 805 | |
Pau Espin Pedrol | 2d6a69e | 2017-12-06 19:26:25 +0100 | [diff] [blame] | 806 | rc = ippool_newip(apn->v4.pool, &member, &addr[i], 0); |
| 807 | if (rc < 0) |
| 808 | goto err_pool_full; |
| 809 | /* copy back */ |
| 810 | memcpy(&addr[i].v4.s_addr, &member->addr.v4, 4); |
jjako | a7cd249 | 2003-04-11 09:40:12 +0000 | [diff] [blame] | 811 | |
Pau Espin Pedrol | 4e43ef5 | 2018-01-26 18:12:19 +0100 | [diff] [blame] | 812 | addrv4 = member; |
| 813 | |
Pau Espin Pedrol | 2d6a69e | 2017-12-06 19:26:25 +0100 | [diff] [blame] | 814 | } else if (addr[i].len == sizeof(struct in6_addr)) { |
| 815 | |
| 816 | /* does this APN actually have an IPv6 pool? */ |
| 817 | if (!apn_supports_ipv6(apn)) |
| 818 | goto err_wrong_af; |
| 819 | |
| 820 | rc = ippool_newip(apn->v6.pool, &member, &addr[i], 0); |
| 821 | if (rc < 0) |
| 822 | goto err_pool_full; |
| 823 | |
| 824 | /* IPv6 doesn't really send the real/allocated address at this point, but just |
| 825 | * the link-identifier which the MS shall use for router solicitation */ |
| 826 | /* initialize upper 64 bits to prefix, they are discarded by MS anyway */ |
| 827 | memcpy(addr[i].v6.s6_addr, &member->addr.v6, 8); |
| 828 | /* use allocated 64bit prefix as lower 64bit, used as link id by MS */ |
| 829 | memcpy(addr[i].v6.s6_addr+8, &member->addr.v6, 8); |
Pau Espin Pedrol | 4e43ef5 | 2018-01-26 18:12:19 +0100 | [diff] [blame] | 830 | |
| 831 | addrv6 = member; |
Pau Espin Pedrol | 2d6a69e | 2017-12-06 19:26:25 +0100 | [diff] [blame] | 832 | } else |
| 833 | OSMO_ASSERT(0); |
| 834 | |
| 835 | pdp->peer[i] = member; |
| 836 | member->peer = pdp; |
| 837 | } |
| 838 | |
| 839 | in46a_to_eua(addr, num_addr, &pdp->eua); |
| 840 | |
Harald Welte | 546884d | 2018-04-25 21:13:06 +0200 | [diff] [blame] | 841 | if (apn->cfg.gtpu_mode == APN_GTPU_MODE_KERNEL_GTP && apn_supports_ipv4(apn)) { |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 842 | /* TODO: In IPv6, EUA doesn't contain the actual IP addr/prefix! */ |
Harald Welte | 698a233 | 2017-11-08 15:09:58 +0900 | [diff] [blame] | 843 | if (gtp_kernel_tunnel_add(pdp, apn->tun.cfg.dev_name) < 0) { |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 844 | LOGPPDP(LOGL_ERROR, pdp, "Cannot add tunnel to kernel: %s\n", strerror(errno)); |
| 845 | gtp_create_context_resp(gsn, pdp, GTPCAUSE_SYS_FAIL); |
| 846 | return 0; |
| 847 | } |
Pau Espin Pedrol | 2d6a69e | 2017-12-06 19:26:25 +0100 | [diff] [blame] | 848 | } |
Harald Welte | 9d9d91b | 2017-10-14 16:22:16 +0200 | [diff] [blame] | 849 | |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 850 | pdp->ipif = apn->tun.tun; /* TODO */ |
Harald Welte | 698a233 | 2017-11-08 15:09:58 +0900 | [diff] [blame] | 851 | pdp->priv = apn; |
Max | 3142d8d | 2017-05-04 17:45:10 +0200 | [diff] [blame] | 852 | |
Pau Espin Pedrol | 4e43ef5 | 2018-01-26 18:12:19 +0100 | [diff] [blame] | 853 | /* TODO: change trap to send 2 IPs */ |
Max | 3142d8d | 2017-05-04 17:45:10 +0200 | [diff] [blame] | 854 | if (!send_trap(gsn, pdp, member, "imsi-ass-ip")) { /* TRAP with IP assignment */ |
Max | 727417d | 2016-08-02 17:10:38 +0200 | [diff] [blame] | 855 | gtp_create_context_resp(gsn, pdp, GTPCAUSE_NO_RESOURCES); |
| 856 | return 0; |
| 857 | } |
Pablo Neira Ayuso | 4b075b6 | 2015-11-17 12:22:42 +0100 | [diff] [blame] | 858 | |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 859 | process_pco(apn, pdp); |
Harald Welte | 1ae9877 | 2017-08-09 20:28:52 +0200 | [diff] [blame] | 860 | |
Harald Welte | 93fed3b | 2017-09-24 11:43:17 +0800 | [diff] [blame] | 861 | /* Transmit G-PDU sequence numbers (only) if configured in APN */ |
| 862 | pdp->tx_gpdu_seq = apn->cfg.tx_gpdu_seq; |
| 863 | |
Pau Espin Pedrol | 4e43ef5 | 2018-01-26 18:12:19 +0100 | [diff] [blame] | 864 | LOGPPDP(LOGL_INFO, pdp, "Successful PDP Context Creation: APN=%s(%s), TEIC=%u, IPv4=%s, IPv6=%s\n", |
| 865 | name_buf, apn->cfg.name, pdp->teic_own, |
| 866 | addrv4 ? inet_ntop(AF_INET, &addrv4->addr.v4, straddrv4, sizeof(straddrv4)) : "none", |
| 867 | addrv6 ? inet_ntop(AF_INET6, &addrv6->addr.v6, straddrv6, sizeof(straddrv6)) : "none"); |
Harald Welte | bed35df | 2011-11-02 13:06:18 +0100 | [diff] [blame] | 868 | gtp_create_context_resp(gsn, pdp, GTPCAUSE_ACC_REQ); |
| 869 | return 0; /* Success */ |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 870 | |
| 871 | err_pool_full: |
| 872 | LOGPPDP(LOGL_ERROR, pdp, "Cannot allocate IP address from pool (full!)\n"); |
| 873 | gtp_create_context_resp(gsn, pdp, -rc); |
| 874 | return 0; /* Already in use, or no more available */ |
Harald Welte | 9d9d91b | 2017-10-14 16:22:16 +0200 | [diff] [blame] | 875 | |
| 876 | err_wrong_af: |
| 877 | LOGPPDP(LOGL_ERROR, pdp, "APN doesn't support requested EUA / AF type\n"); |
| 878 | gtp_create_context_resp(gsn, pdp, GTPCAUSE_UNKNOWN_PDP); |
| 879 | return 0; |
jjako | 52c2414 | 2002-12-16 13:33:51 +0000 | [diff] [blame] | 880 | } |
| 881 | |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 882 | /* Internet-originated IP packet, needs to be sent via GTP towards MS */ |
| 883 | static int cb_tun_ind(struct tun_t *tun, void *pack, unsigned len) |
Harald Welte | bed35df | 2011-11-02 13:06:18 +0100 | [diff] [blame] | 884 | { |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 885 | struct apn_ctx *apn = tun->priv; |
Harald Welte | bed35df | 2011-11-02 13:06:18 +0100 | [diff] [blame] | 886 | struct ippoolm_t *ipm; |
Harald Welte | d12eab9 | 2017-08-02 19:49:47 +0200 | [diff] [blame] | 887 | struct in46_addr dst; |
Harald Welte | 63ebccd | 2017-08-02 21:10:09 +0200 | [diff] [blame] | 888 | struct iphdr *iph = (struct iphdr *)pack; |
Harald Welte | a0d281d | 2017-08-02 21:48:16 +0200 | [diff] [blame] | 889 | struct ip6_hdr *ip6h = (struct ip6_hdr *)pack; |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 890 | struct ippool_t *pool; |
Pau Espin Pedrol | 134855c | 2018-01-30 16:04:53 +0100 | [diff] [blame] | 891 | char straddr[INET6_ADDRSTRLEN]; |
Pau Espin Pedrol | dddbbaa | 2018-01-30 16:16:33 +0100 | [diff] [blame] | 892 | uint8_t pref_offset; |
jjako | c6762cf | 2004-04-28 14:52:58 +0000 | [diff] [blame] | 893 | |
Pau Espin Pedrol | a4942e6 | 2018-01-30 16:01:27 +0100 | [diff] [blame] | 894 | switch (iph->version) { |
| 895 | case 4: |
Harald Welte | d12eab9 | 2017-08-02 19:49:47 +0200 | [diff] [blame] | 896 | if (len < sizeof(*iph) || len < 4*iph->ihl) |
| 897 | return -1; |
| 898 | dst.len = 4; |
Harald Welte | 63ebccd | 2017-08-02 21:10:09 +0200 | [diff] [blame] | 899 | dst.v4.s_addr = iph->daddr; |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 900 | pool = apn->v4.pool; |
Pau Espin Pedrol | a4942e6 | 2018-01-30 16:01:27 +0100 | [diff] [blame] | 901 | break; |
| 902 | case 6: |
Harald Welte | d4d6e09 | 2017-08-08 18:10:43 +0200 | [diff] [blame] | 903 | /* Due to the fact that 3GPP requires an allocation of a |
| 904 | * /64 prefix to each MS, we must instruct |
| 905 | * ippool_getip() below to match only the leading /64 |
Pau Espin Pedrol | dddbbaa | 2018-01-30 16:16:33 +0100 | [diff] [blame] | 906 | * prefix, i.e. the first 8 bytes of the address. If the ll addr |
| 907 | * is used, then the match should be done on the trailing 64 |
| 908 | * bits. */ |
Harald Welte | d4d6e09 | 2017-08-08 18:10:43 +0200 | [diff] [blame] | 909 | dst.len = 8; |
Pau Espin Pedrol | dddbbaa | 2018-01-30 16:16:33 +0100 | [diff] [blame] | 910 | pref_offset = IN6_IS_ADDR_LINKLOCAL(&ip6h->ip6_dst) ? 8 : 0; |
| 911 | memcpy(&dst.v6, ((uint8_t*)&ip6h->ip6_dst) + pref_offset, 8); |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 912 | pool = apn->v6.pool; |
Pau Espin Pedrol | a4942e6 | 2018-01-30 16:01:27 +0100 | [diff] [blame] | 913 | break; |
| 914 | default: |
Pau Espin Pedrol | 55d639f | 2017-12-04 13:17:07 +0100 | [diff] [blame] | 915 | LOGP(DTUN, LOGL_NOTICE, "non-IPv%u packet received from tun\n", iph->version); |
Harald Welte | d12eab9 | 2017-08-02 19:49:47 +0200 | [diff] [blame] | 916 | return -1; |
| 917 | } |
jjako | c6762cf | 2004-04-28 14:52:58 +0000 | [diff] [blame] | 918 | |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 919 | /* IPv6 packet but no IPv6 pool, or IPv4 packet with no IPv4 pool */ |
| 920 | if (!pool) |
| 921 | return 0; |
Harald Welte | bed35df | 2011-11-02 13:06:18 +0100 | [diff] [blame] | 922 | |
Max | 427699e | 2017-12-05 16:30:37 +0100 | [diff] [blame] | 923 | DEBUGP(DTUN, "Received packet for APN(%s) from tun %s", apn->cfg.name, tun->devname); |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 924 | |
| 925 | if (ippool_getip(pool, &ipm, &dst)) { |
Pau Espin Pedrol | 134855c | 2018-01-30 16:04:53 +0100 | [diff] [blame] | 926 | DEBUGPC(DTUN, " with no PDP contex! (%s)\n", iph->version == 4 ? |
| 927 | inet_ntop(AF_INET, &iph->saddr, straddr, sizeof(straddr)) : |
| 928 | inet_ntop(AF_INET6, &ip6h->ip6_src, straddr, sizeof(straddr))); |
Harald Welte | bed35df | 2011-11-02 13:06:18 +0100 | [diff] [blame] | 929 | return 0; |
| 930 | } |
Max | 427699e | 2017-12-05 16:30:37 +0100 | [diff] [blame] | 931 | DEBUGPC(DTUN, "\n"); |
Harald Welte | bed35df | 2011-11-02 13:06:18 +0100 | [diff] [blame] | 932 | |
| 933 | if (ipm->peer) /* Check if a peer protocol is defined */ |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 934 | gtp_data_req(apn->ggsn->gsn, (struct pdp_t *)ipm->peer, pack, len); |
Harald Welte | bed35df | 2011-11-02 13:06:18 +0100 | [diff] [blame] | 935 | return 0; |
jjako | 52c2414 | 2002-12-16 13:33:51 +0000 | [diff] [blame] | 936 | } |
| 937 | |
Harald Welte | d46bcd2 | 2017-08-08 23:27:22 +0200 | [diff] [blame] | 938 | /* RFC3307 link-local scope multicast address */ |
| 939 | static const struct in6_addr all_router_mcast_addr = { |
| 940 | .s6_addr = { 0xff,0x02,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,2 } |
| 941 | }; |
| 942 | |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 943 | /* MS-originated GTP1-U packet, needs to be sent via TUN device */ |
| 944 | static int encaps_tun(struct pdp_t *pdp, void *pack, unsigned len) |
Harald Welte | bed35df | 2011-11-02 13:06:18 +0100 | [diff] [blame] | 945 | { |
Harald Welte | d46bcd2 | 2017-08-08 23:27:22 +0200 | [diff] [blame] | 946 | struct iphdr *iph = (struct iphdr *)pack; |
| 947 | struct ip6_hdr *ip6h = (struct ip6_hdr *)pack; |
Harald Welte | f85fe97 | 2017-09-24 20:00:34 +0800 | [diff] [blame] | 948 | struct tun_t *tun = (struct tun_t *)pdp->ipif; |
| 949 | struct apn_ctx *apn = tun->priv; |
Pau Espin Pedrol | 5b1ef95 | 2018-01-25 20:50:59 +0100 | [diff] [blame] | 950 | char straddr[INET6_ADDRSTRLEN]; |
Pau Espin Pedrol | 7d54ed4 | 2018-01-25 20:09:16 +0100 | [diff] [blame] | 951 | struct ippoolm_t *peer; |
Pau Espin Pedrol | 5b1ef95 | 2018-01-25 20:50:59 +0100 | [diff] [blame] | 952 | uint8_t pref_offset; |
Harald Welte | f85fe97 | 2017-09-24 20:00:34 +0800 | [diff] [blame] | 953 | |
| 954 | OSMO_ASSERT(tun); |
| 955 | OSMO_ASSERT(apn); |
Harald Welte | d46bcd2 | 2017-08-08 23:27:22 +0200 | [diff] [blame] | 956 | |
Max | 427699e | 2017-12-05 16:30:37 +0100 | [diff] [blame] | 957 | LOGPPDP(LOGL_DEBUG, pdp, "Packet received on APN(%s): forwarding to tun %s\n", apn->cfg.name, tun->devname); |
Harald Welte | d46bcd2 | 2017-08-08 23:27:22 +0200 | [diff] [blame] | 958 | |
| 959 | switch (iph->version) { |
| 960 | case 6: |
Pau Espin Pedrol | 7d54ed4 | 2018-01-25 20:09:16 +0100 | [diff] [blame] | 961 | peer = pdp_get_peer_ipv(pdp, true); |
| 962 | if (!peer) { |
| 963 | LOGPPDP(LOGL_ERROR, pdp, "Packet from MS IPv6 with unassigned EUA: %s\n", |
| 964 | osmo_hexdump(pack, len)); |
| 965 | return -1; |
| 966 | } |
| 967 | |
Pau Espin Pedrol | 5b1ef95 | 2018-01-25 20:50:59 +0100 | [diff] [blame] | 968 | /* Validate packet comes from IPaddr assigned to the pdp ctx. |
| 969 | If packet is a LL addr, then EUA is in the lower 64 bits, |
| 970 | otherwise it's used as the 64 prefix */ |
| 971 | pref_offset = IN6_IS_ADDR_LINKLOCAL(&ip6h->ip6_src) ? 8 : 0; |
| 972 | if (memcmp(((uint8_t*)&ip6h->ip6_src) + pref_offset, &peer->addr.v6, 8)) { |
| 973 | LOGPPDP(LOGL_ERROR, pdp, "Packet from MS using unassigned src IPv6: %s\n", |
| 974 | inet_ntop(AF_INET6, &ip6h->ip6_src, straddr, sizeof(straddr))); |
| 975 | return -1; |
| 976 | } |
| 977 | |
Harald Welte | d46bcd2 | 2017-08-08 23:27:22 +0200 | [diff] [blame] | 978 | /* daddr: all-routers multicast addr */ |
| 979 | if (IN6_ARE_ADDR_EQUAL(&ip6h->ip6_dst, &all_router_mcast_addr)) |
Pau Espin Pedrol | 7d54ed4 | 2018-01-25 20:09:16 +0100 | [diff] [blame] | 980 | return handle_router_mcast(pdp->gsn, pdp, &peer->addr.v6, |
| 981 | &apn->v6_lladdr, pack, len); |
Harald Welte | d46bcd2 | 2017-08-08 23:27:22 +0200 | [diff] [blame] | 982 | break; |
| 983 | case 4: |
Pau Espin Pedrol | 7d54ed4 | 2018-01-25 20:09:16 +0100 | [diff] [blame] | 984 | peer = pdp_get_peer_ipv(pdp, false); |
| 985 | if (!peer) { |
| 986 | LOGPPDP(LOGL_ERROR, pdp, "Packet from MS IPv4 with unassigned EUA: %s\n", |
| 987 | osmo_hexdump(pack, len)); |
| 988 | return -1; |
| 989 | } |
Pau Espin Pedrol | 5b1ef95 | 2018-01-25 20:50:59 +0100 | [diff] [blame] | 990 | |
| 991 | /* Validate packet comes from IPaddr assigned to the pdp ctx */ |
| 992 | if (memcmp(&iph->saddr, &peer->addr.v4, sizeof(peer->addr.v4))) { |
| 993 | LOGPPDP(LOGL_ERROR, pdp, "Packet from MS using unassigned src IPv4: %s\n", |
| 994 | inet_ntop(AF_INET, &iph->saddr, straddr, sizeof(straddr))); |
| 995 | return -1; |
| 996 | } |
Harald Welte | d46bcd2 | 2017-08-08 23:27:22 +0200 | [diff] [blame] | 997 | break; |
| 998 | default: |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 999 | LOGPPDP(LOGL_ERROR, pdp, "Packet from MS is neither IPv4 nor IPv6: %s\n", |
| 1000 | osmo_hexdump(pack, len)); |
Harald Welte | d46bcd2 | 2017-08-08 23:27:22 +0200 | [diff] [blame] | 1001 | return -1; |
| 1002 | } |
Harald Welte | bed35df | 2011-11-02 13:06:18 +0100 | [diff] [blame] | 1003 | return tun_encaps((struct tun_t *)pdp->ipif, pack, len); |
jjako | 52c2414 | 2002-12-16 13:33:51 +0000 | [diff] [blame] | 1004 | } |
| 1005 | |
Harald Welte | 632e843 | 2017-09-05 18:12:14 +0200 | [diff] [blame] | 1006 | static char *config_file = "osmo-ggsn.cfg"; |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 1007 | |
| 1008 | /* callback for tun device osmocom select loop integration */ |
| 1009 | static int ggsn_tun_fd_cb(struct osmo_fd *fd, unsigned int what) |
| 1010 | { |
| 1011 | struct apn_ctx *apn = fd->data; |
| 1012 | |
| 1013 | OSMO_ASSERT(what & BSC_FD_READ); |
| 1014 | |
| 1015 | return tun_decaps(apn->tun.tun); |
| 1016 | } |
| 1017 | |
| 1018 | /* callback for libgtp osmocom select loop integration */ |
| 1019 | static int ggsn_gtp_fd_cb(struct osmo_fd *fd, unsigned int what) |
| 1020 | { |
| 1021 | struct ggsn_ctx *ggsn = fd->data; |
| 1022 | int rc; |
| 1023 | |
| 1024 | OSMO_ASSERT(what & BSC_FD_READ); |
| 1025 | |
| 1026 | switch (fd->priv_nr) { |
| 1027 | case 0: |
| 1028 | rc = gtp_decaps0(ggsn->gsn); |
| 1029 | break; |
| 1030 | case 1: |
| 1031 | rc = gtp_decaps1c(ggsn->gsn); |
| 1032 | break; |
| 1033 | case 2: |
| 1034 | rc = gtp_decaps1u(ggsn->gsn); |
| 1035 | break; |
| 1036 | default: |
| 1037 | OSMO_ASSERT(0); |
| 1038 | break; |
| 1039 | } |
| 1040 | return rc; |
| 1041 | } |
| 1042 | |
| 1043 | static void ggsn_gtp_tmr_start(struct ggsn_ctx *ggsn) |
| 1044 | { |
| 1045 | struct timeval next; |
| 1046 | |
| 1047 | /* Retrieve next retransmission as timeval */ |
| 1048 | gtp_retranstimeout(ggsn->gsn, &next); |
| 1049 | |
| 1050 | /* re-schedule the timer */ |
| 1051 | osmo_timer_schedule(&ggsn->gtp_timer, next.tv_sec, next.tv_usec/1000); |
| 1052 | } |
| 1053 | |
| 1054 | /* timer callback for libgtp retransmission and ping */ |
| 1055 | static void ggsn_gtp_tmr_cb(void *data) |
| 1056 | { |
| 1057 | struct ggsn_ctx *ggsn = data; |
| 1058 | |
| 1059 | /* do all the retransmissions as needed */ |
| 1060 | gtp_retrans(ggsn->gsn); |
| 1061 | |
| 1062 | ggsn_gtp_tmr_start(ggsn); |
| 1063 | } |
| 1064 | |
| 1065 | /* To exit gracefully. Used with GCC compilation flag -pg and gprof */ |
| 1066 | static void signal_handler(int s) |
| 1067 | { |
| 1068 | LOGP(DGGSN, LOGL_NOTICE, "signal %d received\n", s); |
| 1069 | switch (s) { |
| 1070 | case SIGINT: |
Harald Welte | e804947 | 2017-08-20 12:44:21 +0200 | [diff] [blame] | 1071 | case SIGTERM: |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 1072 | LOGP(DGGSN, LOGL_NOTICE, "SIGINT received, shutting down\n"); |
| 1073 | end = 1; |
| 1074 | break; |
| 1075 | case SIGABRT: |
| 1076 | case SIGUSR1: |
| 1077 | talloc_report(tall_vty_ctx, stderr); |
| 1078 | talloc_report_full(tall_ggsn_ctx, stderr); |
| 1079 | break; |
| 1080 | case SIGUSR2: |
| 1081 | talloc_report_full(tall_vty_ctx, stderr); |
| 1082 | break; |
| 1083 | default: |
| 1084 | break; |
| 1085 | } |
| 1086 | } |
| 1087 | |
Oliver Smith | 1cde2c1 | 2019-05-13 11:35:03 +0200 | [diff] [blame] | 1088 | /* libgtp callback for confirmations */ |
| 1089 | static int cb_conf(int type, int cause, struct pdp_t *pdp, void *cbp) |
| 1090 | { |
| 1091 | int rc = 0; |
| 1092 | |
| 1093 | if (cause == EOF) |
| 1094 | LOGP(DGGSN, LOGL_NOTICE, "libgtp EOF (type=%u, pdp=%p, cbp=%p)\n", |
| 1095 | type, pdp, cbp); |
| 1096 | |
| 1097 | switch (type) { |
| 1098 | case GTP_DELETE_PDP_REQ: |
| 1099 | /* Remark: We actually never reach this path nowadays because |
| 1100 | only place where we call gtp_delete_context_req2() is during |
| 1101 | apn_stop()->pool_close_all_pdp() path, and in that case we |
| 1102 | free all pdp contexts immediatelly without waiting for |
| 1103 | confirmation since we want to tear down the whole APN |
| 1104 | anyways. As a result, DeleteCtxResponse will never reach here |
| 1105 | since it will be dropped at some point in lower layers in the |
| 1106 | Rx path. This code is nevertheless left here in order to ease |
| 1107 | future developent and avoid possible future memleaks once more |
| 1108 | scenarios where GGSN sends a DeleteCtxRequest are introduced. */ |
| 1109 | if (pdp) |
| 1110 | rc = pdp_freepdp(pdp); |
| 1111 | } |
| 1112 | return rc; |
| 1113 | } |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 1114 | |
| 1115 | /* Start a given GGSN */ |
| 1116 | int ggsn_start(struct ggsn_ctx *ggsn) |
| 1117 | { |
| 1118 | struct apn_ctx *apn; |
| 1119 | int rc; |
| 1120 | |
| 1121 | if (ggsn->started) |
| 1122 | return 0; |
| 1123 | |
| 1124 | LOGPGGSN(LOGL_INFO, ggsn, "Starting GGSN\n"); |
| 1125 | |
| 1126 | /* Start libgtp listener */ |
| 1127 | if (gtp_new(&ggsn->gsn, ggsn->cfg.state_dir, &ggsn->cfg.listen_addr.v4, GTP_MODE_GGSN)) { |
| 1128 | LOGPGGSN(LOGL_ERROR, ggsn, "Failed to create GTP: %s\n", strerror(errno)); |
| 1129 | return -1; |
| 1130 | } |
| 1131 | ggsn->gsn->priv = ggsn; |
| 1132 | |
Harald Welte | 9814677 | 2017-09-05 17:41:20 +0200 | [diff] [blame] | 1133 | /* patch in different addresses to use (in case we're behind NAT, the listen |
| 1134 | * address is different from what we advertise externally) */ |
| 1135 | if (ggsn->cfg.gtpc_addr.v4.s_addr) |
| 1136 | ggsn->gsn->gsnc = ggsn->cfg.gtpc_addr.v4; |
| 1137 | |
| 1138 | if (ggsn->cfg.gtpu_addr.v4.s_addr) |
| 1139 | ggsn->gsn->gsnu = ggsn->cfg.gtpu_addr.v4; |
| 1140 | |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 1141 | /* Register File Descriptors */ |
| 1142 | osmo_fd_setup(&ggsn->gtp_fd0, ggsn->gsn->fd0, BSC_FD_READ, ggsn_gtp_fd_cb, ggsn, 0); |
| 1143 | rc = osmo_fd_register(&ggsn->gtp_fd0); |
| 1144 | OSMO_ASSERT(rc == 0); |
| 1145 | |
| 1146 | osmo_fd_setup(&ggsn->gtp_fd1c, ggsn->gsn->fd1c, BSC_FD_READ, ggsn_gtp_fd_cb, ggsn, 1); |
| 1147 | rc = osmo_fd_register(&ggsn->gtp_fd1c); |
| 1148 | OSMO_ASSERT(rc == 0); |
| 1149 | |
| 1150 | osmo_fd_setup(&ggsn->gtp_fd1u, ggsn->gsn->fd1u, BSC_FD_READ, ggsn_gtp_fd_cb, ggsn, 2); |
| 1151 | rc = osmo_fd_register(&ggsn->gtp_fd1u); |
| 1152 | OSMO_ASSERT(rc == 0); |
| 1153 | |
| 1154 | /* Start GTP re-transmission timer */ |
| 1155 | osmo_timer_setup(&ggsn->gtp_timer, ggsn_gtp_tmr_cb, ggsn); |
Pau Espin Pedrol | cd87c5f | 2019-05-27 16:35:00 +0200 | [diff] [blame] | 1156 | ggsn_gtp_tmr_start(ggsn); |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 1157 | |
| 1158 | gtp_set_cb_data_ind(ggsn->gsn, encaps_tun); |
| 1159 | gtp_set_cb_delete_context(ggsn->gsn, delete_context); |
| 1160 | gtp_set_cb_create_context_ind(ggsn->gsn, create_context_ind); |
Oliver Smith | 1cde2c1 | 2019-05-13 11:35:03 +0200 | [diff] [blame] | 1161 | gtp_set_cb_conf(ggsn->gsn, cb_conf); |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 1162 | |
| 1163 | LOGPGGSN(LOGL_NOTICE, ggsn, "Successfully started\n"); |
| 1164 | ggsn->started = true; |
| 1165 | |
| 1166 | llist_for_each_entry(apn, &ggsn->apn_list, list) |
| 1167 | apn_start(apn); |
| 1168 | |
| 1169 | return 0; |
| 1170 | } |
| 1171 | |
| 1172 | /* Stop a given GGSN */ |
| 1173 | int ggsn_stop(struct ggsn_ctx *ggsn) |
| 1174 | { |
| 1175 | struct apn_ctx *apn; |
| 1176 | |
| 1177 | if (!ggsn->started) |
| 1178 | return 0; |
| 1179 | |
| 1180 | /* iterate over all APNs and stop them */ |
| 1181 | llist_for_each_entry(apn, &ggsn->apn_list, list) |
Pau Espin Pedrol | 72ab4bc | 2019-05-29 19:08:26 +0200 | [diff] [blame] | 1182 | apn_stop(apn); |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 1183 | |
| 1184 | osmo_timer_del(&ggsn->gtp_timer); |
| 1185 | |
| 1186 | osmo_fd_unregister(&ggsn->gtp_fd1u); |
| 1187 | osmo_fd_unregister(&ggsn->gtp_fd1c); |
| 1188 | osmo_fd_unregister(&ggsn->gtp_fd0); |
| 1189 | |
| 1190 | if (ggsn->gsn) { |
| 1191 | gtp_free(ggsn->gsn); |
| 1192 | ggsn->gsn = NULL; |
| 1193 | } |
| 1194 | |
| 1195 | ggsn->started = false; |
| 1196 | return 0; |
| 1197 | } |
| 1198 | |
| 1199 | static void print_usage() |
| 1200 | { |
| 1201 | printf("Usage: osmo-ggsn [-h] [-D] [-c configfile] [-V]\n"); |
| 1202 | } |
| 1203 | |
| 1204 | static void print_help() |
| 1205 | { |
| 1206 | printf( " Some useful help...\n" |
| 1207 | " -h --help This help text\n" |
| 1208 | " -D --daemonize Fork the process into a background daemon\n" |
| 1209 | " -c --config-file filename The config file to use\n" |
| 1210 | " -V --version Print the version of OsmoGGSN\n" |
| 1211 | ); |
| 1212 | } |
| 1213 | |
| 1214 | static void handle_options(int argc, char **argv) |
| 1215 | { |
| 1216 | while (1) { |
| 1217 | int option_index = 0, c; |
| 1218 | static struct option long_options[] = { |
| 1219 | { "help", 0, 0, 'h' }, |
| 1220 | { "daemonize", 0, 0, 'D' }, |
| 1221 | { "config-file", 1, 0, 'c' }, |
| 1222 | { "version", 0, 0, 'V' }, |
| 1223 | { 0, 0, 0, 0 } |
| 1224 | }; |
| 1225 | |
| 1226 | c = getopt_long(argc, argv, "hdc:V", long_options, &option_index); |
| 1227 | if (c == -1) |
| 1228 | break; |
| 1229 | |
| 1230 | switch (c) { |
| 1231 | case 'h': |
| 1232 | print_usage(); |
| 1233 | print_help(); |
| 1234 | exit(0); |
| 1235 | case 'D': |
| 1236 | daemonize = 1; |
| 1237 | break; |
| 1238 | case 'c': |
| 1239 | config_file = optarg; |
| 1240 | break; |
| 1241 | case 'V': |
| 1242 | print_version(1); |
| 1243 | exit(0); |
| 1244 | break; |
| 1245 | } |
| 1246 | } |
| 1247 | } |
| 1248 | |
jjako | 52c2414 | 2002-12-16 13:33:51 +0000 | [diff] [blame] | 1249 | int main(int argc, char **argv) |
| 1250 | { |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 1251 | struct ggsn_ctx *ggsn; |
| 1252 | int rc; |
jjako | 52c2414 | 2002-12-16 13:33:51 +0000 | [diff] [blame] | 1253 | |
Harald Welte | 632e843 | 2017-09-05 18:12:14 +0200 | [diff] [blame] | 1254 | tall_ggsn_ctx = talloc_named_const(NULL, 0, "OsmoGGSN"); |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 1255 | msgb_talloc_ctx_init(tall_ggsn_ctx, 0); |
Harald Welte | 3e443ca | 2018-02-14 01:04:04 +0100 | [diff] [blame] | 1256 | g_vty_info.tall_ctx = tall_ggsn_ctx; |
jjako | 52c2414 | 2002-12-16 13:33:51 +0000 | [diff] [blame] | 1257 | |
Harald Welte | e804947 | 2017-08-20 12:44:21 +0200 | [diff] [blame] | 1258 | /* Handle keyboard interrupt SIGINT */ |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 1259 | signal(SIGINT, &signal_handler); |
Harald Welte | e804947 | 2017-08-20 12:44:21 +0200 | [diff] [blame] | 1260 | signal(SIGTERM, &signal_handler); |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 1261 | signal(SIGABRT, &signal_handler); |
| 1262 | signal(SIGUSR1, &signal_handler); |
| 1263 | signal(SIGUSR2, &signal_handler); |
jjako | 52c2414 | 2002-12-16 13:33:51 +0000 | [diff] [blame] | 1264 | |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 1265 | osmo_init_ignore_signals(); |
Pau Espin Pedrol | 042a445 | 2018-04-17 14:31:42 +0200 | [diff] [blame] | 1266 | osmo_init_logging2(tall_ggsn_ctx, &log_info); |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 1267 | osmo_stats_init(tall_ggsn_ctx); |
jjako | 0141d20 | 2004-01-09 15:19:20 +0000 | [diff] [blame] | 1268 | |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 1269 | vty_init(&g_vty_info); |
| 1270 | logging_vty_add_cmds(NULL); |
Harald Welte | 3e443ca | 2018-02-14 01:04:04 +0100 | [diff] [blame] | 1271 | osmo_talloc_vty_add_cmds(); |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 1272 | osmo_stats_vty_add_cmds(&log_info); |
| 1273 | ggsn_vty_init(); |
| 1274 | ctrl_vty_init(tall_ggsn_ctx); |
| 1275 | |
| 1276 | handle_options(argc, argv); |
| 1277 | |
| 1278 | rate_ctr_init(tall_ggsn_ctx); |
| 1279 | |
| 1280 | rc = vty_read_config_file(config_file, NULL); |
| 1281 | if (rc < 0) { |
| 1282 | fprintf(stderr, "Failed to open config file: '%s'\n", config_file); |
| 1283 | exit(2); |
Harald Welte | bed35df | 2011-11-02 13:06:18 +0100 | [diff] [blame] | 1284 | } |
jjako | 52c2414 | 2002-12-16 13:33:51 +0000 | [diff] [blame] | 1285 | |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 1286 | rc = telnet_init_dynif(tall_ggsn_ctx, NULL, vty_get_bind_addr(), OSMO_VTY_PORT_GGSN); |
| 1287 | if (rc < 0) |
Harald Welte | bed35df | 2011-11-02 13:06:18 +0100 | [diff] [blame] | 1288 | exit(1); |
Holger Hans Peter Freyther | 9c0ff4f | 2014-03-23 10:07:26 +0100 | [diff] [blame] | 1289 | |
Pau Espin Pedrol | 3e0baa6 | 2018-06-19 11:50:02 +0200 | [diff] [blame] | 1290 | g_ctrlh = ctrl_interface_setup_dynip(NULL, ctrl_vty_get_bind_addr(), |
| 1291 | OSMO_CTRL_PORT_GGSN, NULL); |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 1292 | if (!g_ctrlh) { |
| 1293 | LOGP(DGGSN, LOGL_ERROR, "Failed to create CTRL interface.\n"); |
Harald Welte | bed35df | 2011-11-02 13:06:18 +0100 | [diff] [blame] | 1294 | exit(1); |
| 1295 | } |
jjako | 88c2216 | 2003-07-06 19:33:18 +0000 | [diff] [blame] | 1296 | |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 1297 | if (daemonize) { |
| 1298 | rc = osmo_daemonize(); |
| 1299 | if (rc < 0) { |
| 1300 | perror("Error during daemonize"); |
Harald Welte | bed35df | 2011-11-02 13:06:18 +0100 | [diff] [blame] | 1301 | exit(1); |
| 1302 | } |
| 1303 | } |
jjako | 1d3db97 | 2004-01-16 09:56:56 +0000 | [diff] [blame] | 1304 | |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 1305 | #if 0 |
Harald Welte | bed35df | 2011-11-02 13:06:18 +0100 | [diff] [blame] | 1306 | /* qos */ |
| 1307 | qos.l = 3; |
| 1308 | qos.v[2] = (args_info.qos_arg) & 0xff; |
| 1309 | qos.v[1] = ((args_info.qos_arg) >> 8) & 0xff; |
| 1310 | qos.v[0] = ((args_info.qos_arg) >> 16) & 0xff; |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 1311 | #endif |
jjako | a7cd249 | 2003-04-11 09:40:12 +0000 | [diff] [blame] | 1312 | |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 1313 | /* Main select loop */ |
| 1314 | while (!end) { |
| 1315 | osmo_select_main(0); |
Harald Welte | bed35df | 2011-11-02 13:06:18 +0100 | [diff] [blame] | 1316 | } |
jjako | e014978 | 2003-07-06 17:07:04 +0000 | [diff] [blame] | 1317 | |
Harald Welte | dda21ed | 2017-08-12 15:07:02 +0200 | [diff] [blame] | 1318 | llist_for_each_entry(ggsn, &g_ggsn_list, list) |
| 1319 | ggsn_stop(ggsn); |
Harald Welte | bed35df | 2011-11-02 13:06:18 +0100 | [diff] [blame] | 1320 | |
Max | 3fc9cc9 | 2019-03-14 11:16:55 +0100 | [diff] [blame] | 1321 | return 0; |
jjako | 52c2414 | 2002-12-16 13:33:51 +0000 | [diff] [blame] | 1322 | } |