blob: 03de8ccd23dc741b8cf51c04d879977c4a30216b [file] [log] [blame]
Harald Welte2720e732010-05-17 00:44:57 +02001/* GPRS SGSN integration with libgtp of OpenGGSN */
2
3/* (C) 2010 by Harald Welte <laforge@gnumonks.org>
4 * (C) 2010 by On Waves
5 * All Rights Reserved
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 2 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 along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 */
22
23#include <unistd.h>
24#include <stdio.h>
25#include <stdlib.h>
26#include <string.h>
27#include <getopt.h>
28#include <errno.h>
29#include <signal.h>
30#include <sys/fcntl.h>
31#include <sys/stat.h>
32#include <sys/types.h>
33#include <sys/socket.h>
34#include <netinet/in.h>
35#include <arpa/inet.h>
36
37#include <osmocore/talloc.h>
38#include <osmocore/select.h>
39#include <osmocore/rate_ctr.h>
Harald Welte6abf94e2010-05-18 10:35:06 +020040#include <openbsc/gsm_04_08_gprs.h>
Harald Welte2720e732010-05-17 00:44:57 +020041
42#include <openbsc/signal.h>
43#include <openbsc/debug.h>
44#include <openbsc/sgsn.h>
Harald Welteebabdea2010-06-01 18:28:10 +020045#include <openbsc/gprs_llc.h>
46#include <openbsc/gprs_bssgp.h>
Harald Welte2720e732010-05-17 00:44:57 +020047#include <openbsc/gprs_sgsn.h>
Harald Welte6abf94e2010-05-18 10:35:06 +020048#include <openbsc/gprs_gmm.h>
Harald Welte2720e732010-05-17 00:44:57 +020049
50#include <gtp.h>
51#include <pdp.h>
52
Harald Welte2720e732010-05-17 00:44:57 +020053const struct value_string gtp_cause_strs[] = {
54 { GTPCAUSE_REQ_IMSI, "Request IMSI" },
55 { GTPCAUSE_REQ_IMEI, "Request IMEI" },
56 { GTPCAUSE_REQ_IMSI_IMEI, "Request IMSI and IMEI" },
57 { GTPCAUSE_NO_ID_NEEDED, "No identity needed" },
58 { GTPCAUSE_MS_REFUSES_X, "MS refuses" },
59 { GTPCAUSE_MS_NOT_RESP_X, "MS is not GPRS responding" },
60 { GTPCAUSE_ACC_REQ, "Request accepted" },
61 { GTPCAUSE_NON_EXIST, "Non-existent" },
62 { GTPCAUSE_INVALID_MESSAGE, "Invalid message format" },
63 { GTPCAUSE_IMSI_NOT_KNOWN, "IMSI not known" },
64 { GTPCAUSE_MS_DETACHED, "MS is GPRS detached" },
65 { GTPCAUSE_MS_NOT_RESP, "MS is not GPRS responding" },
66 { GTPCAUSE_MS_REFUSES, "MS refuses" },
67 { GTPCAUSE_NO_RESOURCES, "No resources available" },
68 { GTPCAUSE_NOT_SUPPORTED, "Service not supported" },
69 { GTPCAUSE_MAN_IE_INCORRECT, "Mandatory IE incorrect" },
70 { GTPCAUSE_MAN_IE_MISSING, "Mandatory IE missing" },
71 { GTPCAUSE_OPT_IE_INCORRECT, "Optional IE incorrect" },
72 { GTPCAUSE_SYS_FAIL, "System failure" },
73 { GTPCAUSE_ROAMING_REST, "Roaming restrictions" },
74 { GTPCAUSE_PTIMSI_MISMATCH, "P-TMSI Signature mismatch" },
75 { GTPCAUSE_CONN_SUSP, "GPRS connection suspended" },
76 { GTPCAUSE_AUTH_FAIL, "Authentication failure" },
77 { GTPCAUSE_USER_AUTH_FAIL, "User authentication failed" },
78 { GTPCAUSE_CONTEXT_NOT_FOUND, "Context not found" },
79 { GTPCAUSE_ADDR_OCCUPIED, "All dynamic PDP addresses occupied" },
80 { GTPCAUSE_NO_MEMORY, "No memory is available" },
81 { GTPCAUSE_RELOC_FAIL, "Relocation failure" },
82 { GTPCAUSE_UNKNOWN_MAN_EXTHEADER, "Unknown mandatory ext. header" },
83 { GTPCAUSE_SEM_ERR_TFT, "Semantic error in TFT operation" },
84 { GTPCAUSE_SYN_ERR_TFT, "Syntactic error in TFT operation" },
85 { GTPCAUSE_SEM_ERR_FILTER, "Semantic errors in packet filter" },
86 { GTPCAUSE_SYN_ERR_FILTER, "Syntactic errors in packet filter" },
87 { GTPCAUSE_MISSING_APN, "Missing or unknown APN" },
88 { GTPCAUSE_UNKNOWN_PDP, "Unknown PDP address or PDP type" },
89 { 0, NULL }
90};
91
92/* generate a PDP context based on the IE's from the 04.08 message,
93 * and send the GTP create pdp context request to the GGSN */
Harald Welte77289c22010-05-18 14:32:29 +020094struct sgsn_pdp_ctx *sgsn_create_pdp_ctx(struct sgsn_ggsn_ctx *ggsn,
Harald Welted193cb32010-05-17 22:58:03 +020095 struct sgsn_mm_ctx *mmctx,
96 uint16_t nsapi,
97 struct tlv_parsed *tp)
Harald Welte2720e732010-05-17 00:44:57 +020098{
Harald Welted193cb32010-05-17 22:58:03 +020099 struct sgsn_pdp_ctx *pctx;
Harald Welte2720e732010-05-17 00:44:57 +0200100 struct pdp_t *pdp;
Harald Weltecd4dd4d2010-05-18 17:20:49 +0200101 uint64_t imsi_ui64 = 0;
Harald Welte2720e732010-05-17 00:44:57 +0200102 int rc;
103
Harald Welte77289c22010-05-18 14:32:29 +0200104 LOGP(DGPRS, LOGL_ERROR, "Create PDP Context\n");
Harald Welted193cb32010-05-17 22:58:03 +0200105 pctx = sgsn_pdp_ctx_alloc(mmctx, nsapi);
106 if (!pctx) {
107 LOGP(DGPRS, LOGL_ERROR, "Couldn't allocate PDP Ctx\n");
108 return NULL;
109 }
110
Harald Welte2720e732010-05-17 00:44:57 +0200111 rc = pdp_newpdp(&pdp, imsi_ui64, nsapi, NULL);
112 if (rc) {
Harald Welted193cb32010-05-17 22:58:03 +0200113 LOGP(DGPRS, LOGL_ERROR, "Out of libgtp PDP Contexts\n");
114 return NULL;
Harald Welte2720e732010-05-17 00:44:57 +0200115 }
Harald Welted193cb32010-05-17 22:58:03 +0200116 pctx->lib = pdp;
117 pctx->ggsn = ggsn;
118
Harald Welte2720e732010-05-17 00:44:57 +0200119 //pdp->peer = /* sockaddr_in of GGSN (receive) */
120 //pdp->ipif = /* not used by library */
121 pdp->version = ggsn->gtp_version;
122 pdp->hisaddr0 = ggsn->remote_addr;
123 pdp->hisaddr1 = ggsn->remote_addr;
124 //pdp->cch_pdp = 512; /* Charging Flat Rate */
125
126 /* MS provided APN, subscription not verified */
127 pdp->selmode = 0x01;
128
129 /* IMSI, TEID/TEIC, FLLU/FLLC, TID, NSAPI set in pdp_newpdp */
130
131 /* FIXME: MSISDN in BCD format from mmctx */
132 //pdp->msisdn.l/.v
133
134 /* End User Address from GMM requested PDP address */
135 pdp->eua.l = TLVP_LEN(tp, OSMO_IE_GSM_REQ_PDP_ADDR);
136 if (pdp->eua.l > sizeof(pdp->eua.v))
137 pdp->eua.l = sizeof(pdp->eua.v);
138 memcpy(pdp->eua.v, TLVP_VAL(tp, OSMO_IE_GSM_REQ_PDP_ADDR),
139 pdp->eua.l);
140 /* Highest 4 bits of first byte need to be set to 1, otherwise
141 * the IE is identical with the 04.08 PDP Address IE */
142 pdp->eua.v[0] |= 0xf0;
143
144 /* APN name from GMM */
145 pdp->apn_use.l = TLVP_LEN(tp, GSM48_IE_GSM_APN);
146 if (pdp->apn_use.l > sizeof(pdp->apn_use.v))
147 pdp->apn_use.l = sizeof(pdp->apn_use.v);
148 memcpy(pdp->apn_use.v, TLVP_VAL(tp, GSM48_IE_GSM_APN),
149 pdp->apn_use.l);
150
151 /* Protocol Configuration Options from GMM */
152 pdp->pco_req.l = TLVP_LEN(tp, GSM48_IE_GSM_PROTO_CONF_OPT);
153 if (pdp->pco_req.l > sizeof(pdp->pco_req.v))
154 pdp->pco_req.l = sizeof(pdp->pco_req.v);
155 memcpy(pdp->pco_req.v, TLVP_VAL(tp, GSM48_IE_GSM_PROTO_CONF_OPT),
156 pdp->pco_req.l);
157
158 /* QoS options from GMM */
159 pdp->qos_req.l = TLVP_LEN(tp, OSMO_IE_GSM_REQ_QOS);
160 if (pdp->qos_req.l > sizeof(pdp->qos_req.v))
161 pdp->qos_req.l = sizeof(pdp->qos_req.v);
162 memcpy(pdp->qos_req.v, TLVP_VAL(tp, OSMO_IE_GSM_REQ_QOS),
163 pdp->qos_req.l);
164
165 /* SGSN address for control plane */
166 pdp->gsnlc.l = sizeof(sgsn->cfg.gtp_listenaddr);
167 memcpy(pdp->gsnlc.v, &sgsn->cfg.gtp_listenaddr,
168 sizeof(sgsn->cfg.gtp_listenaddr));
169
170 /* SGSN address for user plane */
171 pdp->gsnlu.l = sizeof(sgsn->cfg.gtp_listenaddr);
172 memcpy(pdp->gsnlu.v, &sgsn->cfg.gtp_listenaddr,
173 sizeof(sgsn->cfg.gtp_listenaddr));
174
Harald Welte6abf94e2010-05-18 10:35:06 +0200175 /* change pdp state to 'requested' */
176 pctx->state = PDP_STATE_CR_REQ;
Harald Welte2720e732010-05-17 00:44:57 +0200177
Harald Welted193cb32010-05-17 22:58:03 +0200178 rc = gtp_create_context_req(ggsn->gsn, pdp, pctx);
179 /* FIXME */
180
181 return pctx;
Harald Welte2720e732010-05-17 00:44:57 +0200182}
183
Harald Welte77289c22010-05-18 14:32:29 +0200184int sgsn_delete_pdp_ctx(struct sgsn_pdp_ctx *pctx)
185{
186 LOGP(DGPRS, LOGL_ERROR, "Delete PDP Context\n");
187
188 /* FIXME: decide if we need teardown or not ! */
189 return gtp_delete_context_req(pctx->ggsn->gsn, pctx->lib, pctx, 1);
190}
Harald Welte6abf94e2010-05-18 10:35:06 +0200191
192struct cause_map {
193 uint8_t cause_in;
194 uint8_t cause_out;
195};
196
197static uint8_t cause_map(const struct cause_map *map, uint8_t in, uint8_t deflt)
198{
199 const struct cause_map *m;
200
201 for (m = map; m->cause_in && m->cause_out; m++) {
202 if (m->cause_in == in)
203 return m->cause_out;
204 }
205 return deflt;
206}
207
208/* how do we map from gtp cause to SM cause */
209static const struct cause_map gtp2sm_cause_map[] = {
210 { GTPCAUSE_NO_RESOURCES, GSM_CAUSE_INSUFF_RSRC },
211 { GTPCAUSE_NOT_SUPPORTED, GSM_CAUSE_SERV_OPT_NOTSUPP },
212 { GTPCAUSE_MAN_IE_INCORRECT, GSM_CAUSE_INV_MAND_INFO },
213 { GTPCAUSE_MAN_IE_MISSING, GSM_CAUSE_INV_MAND_INFO },
214 { GTPCAUSE_OPT_IE_INCORRECT, GSM_CAUSE_PROTO_ERR_UNSPEC },
215 { GTPCAUSE_SYS_FAIL, GSM_CAUSE_NET_FAIL },
216 { GTPCAUSE_ROAMING_REST, GSM_CAUSE_REQ_SERV_OPT_NOTSUB },
217 { GTPCAUSE_PTIMSI_MISMATCH, GSM_CAUSE_PROTO_ERR_UNSPEC },
218 { GTPCAUSE_CONN_SUSP, GSM_CAUSE_PROTO_ERR_UNSPEC },
219 { GTPCAUSE_AUTH_FAIL, GSM_CAUSE_AUTH_FAILED },
220 { GTPCAUSE_USER_AUTH_FAIL, GSM_CAUSE_ACT_REJ_GGSN },
221 { GTPCAUSE_CONTEXT_NOT_FOUND, GSM_CAUSE_PROTO_ERR_UNSPEC },
222 { GTPCAUSE_ADDR_OCCUPIED, GSM_CAUSE_INSUFF_RSRC },
223 { GTPCAUSE_NO_MEMORY, GSM_CAUSE_INSUFF_RSRC },
224 { GTPCAUSE_RELOC_FAIL, GSM_CAUSE_PROTO_ERR_UNSPEC },
225 { GTPCAUSE_UNKNOWN_MAN_EXTHEADER, GSM_CAUSE_PROTO_ERR_UNSPEC },
226 { GTPCAUSE_MISSING_APN, GSM_CAUSE_MISSING_APN },
227 { GTPCAUSE_UNKNOWN_PDP, GSM_CAUSE_UNKNOWN_PDP },
228 { 0, 0 }
229};
230
Harald Welte2720e732010-05-17 00:44:57 +0200231/* The GGSN has confirmed the creation of a PDP Context */
232static int create_pdp_conf(struct pdp_t *pdp, void *cbp, int cause)
233{
Harald Welted193cb32010-05-17 22:58:03 +0200234 struct sgsn_pdp_ctx *pctx = cbp;
Harald Welte6abf94e2010-05-18 10:35:06 +0200235 uint8_t reject_cause;
Harald Welte2720e732010-05-17 00:44:57 +0200236
237 DEBUGP(DGPRS, "Received CREATE PDP CTX CONF, cause=%d(%s)\n",
238 cause, get_value_string(gtp_cause_strs, cause));
239
240 /* Check for cause value if it was really successful */
241 if (cause < 0) {
242 LOGP(DGPRS, LOGL_NOTICE, "Create PDP ctx req timed out\n");
Harald Welte1371f7d2010-06-01 11:52:41 +0200243 if (pdp && pdp->version == 1) {
Harald Welte2720e732010-05-17 00:44:57 +0200244 pdp->version = 0;
Harald Welte8fc1a462010-05-17 00:53:10 +0200245 gtp_create_context_req(sgsn->gsn, pdp, cbp);
Harald Welte2720e732010-05-17 00:44:57 +0200246 return 0;
247 } else {
Harald Welte6abf94e2010-05-18 10:35:06 +0200248 reject_cause = GSM_CAUSE_NET_FAIL;
249 goto reject;
Harald Welte2720e732010-05-17 00:44:57 +0200250 }
251 }
252
253 /* Check for cause value if it was really successful */
254 if (cause != GTPCAUSE_ACC_REQ) {
Harald Welte6abf94e2010-05-18 10:35:06 +0200255 reject_cause = cause_map(gtp2sm_cause_map, cause,
256 GSM_CAUSE_ACT_REJ_GGSN);
257 goto reject;
Harald Welte2720e732010-05-17 00:44:57 +0200258 }
259
Harald Welteebabdea2010-06-01 18:28:10 +0200260 /* Activate the SNDCP layer */
261 sndcp_sm_activate_ind(&pctx->mm->llme->lle[pctx->sapi], pctx->nsapi);
262
Harald Welte6abf94e2010-05-18 10:35:06 +0200263 /* Send PDP CTX ACT to MS */
264 return gsm48_tx_gsm_act_pdp_acc(pctx);
265
266reject:
267 pctx->state = PDP_STATE_NONE;
Harald Welte1371f7d2010-06-01 11:52:41 +0200268 if (pdp)
269 pdp_freepdp(pdp);
Harald Welte6abf94e2010-05-18 10:35:06 +0200270 sgsn_pdp_ctx_free(pctx);
271 /* Send PDP CTX ACT REJ to MS */
272 return gsm48_tx_gsm_act_pdp_rej(pctx->mm, pdp->ti, reject_cause,
273 0, NULL);
274
275 return EOF;
Harald Welte2720e732010-05-17 00:44:57 +0200276}
277
Harald Welte2720e732010-05-17 00:44:57 +0200278/* Confirmation of a PDP Context Delete */
Harald Welte77289c22010-05-18 14:32:29 +0200279static int delete_pdp_conf(struct pdp_t *pdp, void *cbp, int cause)
Harald Welte2720e732010-05-17 00:44:57 +0200280{
Harald Welte77289c22010-05-18 14:32:29 +0200281 struct sgsn_pdp_ctx *pctx = cbp;
282 int rc;
283
Harald Welte2720e732010-05-17 00:44:57 +0200284 DEBUGP(DGPRS, "Received DELETE PDP CTX CONF, cause=%d(%s)\n",
285 cause, get_value_string(gtp_cause_strs, cause));
Harald Welte77289c22010-05-18 14:32:29 +0200286
287 /* Confirm deactivation of PDP context to MS */
288 rc = gsm48_tx_gsm_deact_pdp_acc(pctx);
289
290 sgsn_pdp_ctx_free(pctx);
291
292 return rc;
Harald Welte2720e732010-05-17 00:44:57 +0200293}
294
295/* Confirmation of an GTP ECHO request */
296static int echo_conf(int recovery)
297{
298 if (recovery < 0) {
299 DEBUGP(DGPRS, "GTP Echo Request timed out\n");
300 /* FIXME: if version == 1, retry with version 0 */
301 } else {
302 DEBUGP(DGPRS, "GTP Rx Echo Response\n");
303 }
304 return 0;
305}
306
307/* libgtp callback for confirmations */
308static int cb_conf(int type, int cause, struct pdp_t *pdp, void *cbp)
309{
310 DEBUGP(DGPRS, "libgtp cb_conf(type=%d, cause=%d, pdp=%p, cbp=%p)\n",
311 type, cause, pdp, cbp);
312
313 if (cause == EOF)
314 LOGP(DGPRS, LOGL_ERROR, "libgtp EOF (type=%u, pdp=%p, cbp=%p)\n",
315 type, pdp, cbp);
316
317 switch (type) {
318 case GTP_ECHO_REQ:
319 return echo_conf(cause);
320 case GTP_CREATE_PDP_REQ:
321 return create_pdp_conf(pdp, cbp, cause);
322 case GTP_DELETE_PDP_REQ:
Harald Welte77289c22010-05-18 14:32:29 +0200323 return delete_pdp_conf(pdp, cbp, cause);
Harald Welte2720e732010-05-17 00:44:57 +0200324 default:
325 break;
326 }
327 return 0;
328}
329
330/* Called whenever a PDP context is deleted for any reason */
331static int cb_delete_context(struct pdp_t *pdp)
332{
333 LOGP(DGPRS, LOGL_INFO, "PDP Context was deleted\n");
334 return 0;
335}
336
337/* Called when we receive a Version Not Supported message */
338static int cb_unsup_ind(struct sockaddr_in *peer)
339{
340 LOGP(DGPRS, LOGL_INFO, "GTP Version not supported Indication "
341 "from %s:%u\n", inet_ntoa(peer->sin_addr),
342 ntohs(peer->sin_port));
343 return 0;
344}
345
346/* Called when we receive a Supported Ext Headers Notification */
347static int cb_extheader_ind(struct sockaddr_in *peer)
348{
349 LOGP(DGPRS, LOGL_INFO, "GTP Supported Ext Headers Noficiation "
350 "from %s:%u\n", inet_ntoa(peer->sin_addr),
351 ntohs(peer->sin_port));
352 return 0;
353}
354
355/* Called whenever we recive a DATA packet */
356static int cb_data_ind(struct pdp_t *pdp, void *packet, unsigned int len)
357{
358 DEBUGP(DGPRS, "GTP DATA IND from GGSN, length=%u\n", len);
Harald Welte6abf94e2010-05-18 10:35:06 +0200359 /* FIXME: resolve PDP/MM context, forward to SNDCP layer */
Harald Welte2720e732010-05-17 00:44:57 +0200360
361 return 0;
362}
363
Harald Welteebabdea2010-06-01 18:28:10 +0200364/* Called by SNDCP when it has received/re-assembled a N-PDU */
365int sgsn_rx_sndcp_ud_ind(uint32_t tlli, uint8_t nsapi, struct msgb *msg,
366 uint32_t npdu_len, uint8_t *npdu)
367{
368 struct sgsn_mm_ctx *mmctx;
369 struct sgsn_pdp_ctx *pdp;
370 struct gprs_ra_id ra_id;
371
372 /* look-up the MM context for this message */
373 bssgp_parse_cell_id(&ra_id, msgb_bcid(msg));
374 mmctx = sgsn_mm_ctx_by_tlli(tlli, &ra_id);
375 if (!mmctx) {
376 LOGP(DGPRS, LOGL_ERROR,
377 "Cannot find MM CTX for TLLI %08x\n", tlli);
378 return -EIO;
379 }
380 /* look-up the PDP context for this message */
381 pdp = sgsn_pdp_ctx_by_nsapi(mmctx, nsapi);
382 if (!pdp) {
383 LOGP(DGPRS, LOGL_ERROR, "Cannot find PDP CTX for "
384 "TLLI=%08x, NSAPI=%u\n", tlli, nsapi);
385 return -EIO;
386 }
387 if (!pdp->lib) {
388 LOGP(DGPRS, LOGL_ERROR, "PDP CTX without libgtp\n");
389 return -EIO;
390 }
391 return gtp_data_req(pdp->ggsn->gsn, pdp->lib, npdu, npdu_len);
392}
393
Harald Welte2720e732010-05-17 00:44:57 +0200394/* libgtp select loop integration */
395static int sgsn_gtp_fd_cb(struct bsc_fd *fd, unsigned int what)
396{
397 struct sgsn_instance *sgi = fd->data;
398 int rc;
399
400 if (!(what & BSC_FD_READ))
401 return 0;
402
403 switch (fd->priv_nr) {
404 case 0:
405 rc = gtp_decaps0(sgi->gsn);
406 break;
407 case 1:
408 rc = gtp_decaps1c(sgi->gsn);
409 break;
410 case 2:
411 rc = gtp_decaps1u(sgi->gsn);
412 break;
Harald Weltecd4dd4d2010-05-18 17:20:49 +0200413 default:
414 rc = -EINVAL;
415 break;
Harald Welte2720e732010-05-17 00:44:57 +0200416 }
417 return rc;
418}
419
Harald Welte2720e732010-05-17 00:44:57 +0200420static void sgsn_gtp_tmr_start(struct sgsn_instance *sgi)
421{
Harald Welteb4a31292010-05-18 18:24:53 +0200422 struct timeval next;
Harald Welte2720e732010-05-17 00:44:57 +0200423
424 /* Retrieve next retransmission as struct timeval */
425 gtp_retranstimeout(sgi->gsn, &next);
426
Harald Welte2720e732010-05-17 00:44:57 +0200427 /* re-schedule the timer */
Harald Welteb4a31292010-05-18 18:24:53 +0200428 bsc_schedule_timer(&sgi->gtp_timer, next.tv_sec, next.tv_usec/1000);
Harald Welte2720e732010-05-17 00:44:57 +0200429}
430
431/* timer callback for libgtp retransmissions and ping */
432static void sgsn_gtp_tmr_cb(void *data)
433{
434 struct sgsn_instance *sgi = data;
435
436 /* Do all the retransmissions as needed */
437 gtp_retrans(sgi->gsn);
438
439 sgsn_gtp_tmr_start(sgi);
440}
441
442int sgsn_gtp_init(struct sgsn_instance *sgi)
443{
444 int rc;
445 struct gsn_t *gsn;
446
447 rc = gtp_new(&sgi->gsn, sgi->cfg.gtp_statedir,
448 &sgi->cfg.gtp_listenaddr.sin_addr, GTP_MODE_SGSN);
449 if (rc) {
450 LOGP(DGPRS, LOGL_ERROR, "Failed to create GTP: %d\n", rc);
451 return rc;
452 }
453 gsn = sgi->gsn;
454
455 sgi->gtp_fd0.fd = gsn->fd0;
456 sgi->gtp_fd0.priv_nr = 0;
457 sgi->gtp_fd0.data = sgi;
Harald Welte322a5ee2010-05-18 13:13:11 +0200458 sgi->gtp_fd0.when = BSC_FD_READ;
Harald Welte2720e732010-05-17 00:44:57 +0200459 sgi->gtp_fd0.cb = sgsn_gtp_fd_cb;
460 rc = bsc_register_fd(&sgi->gtp_fd0);
461 if (rc < 0)
462 return rc;
463
464 sgi->gtp_fd1c.fd = gsn->fd1c;
465 sgi->gtp_fd1c.priv_nr = 1;
466 sgi->gtp_fd1c.data = sgi;
Harald Welte322a5ee2010-05-18 13:13:11 +0200467 sgi->gtp_fd1c.when = BSC_FD_READ;
Harald Welte2720e732010-05-17 00:44:57 +0200468 sgi->gtp_fd1c.cb = sgsn_gtp_fd_cb;
469 bsc_register_fd(&sgi->gtp_fd1c);
470 if (rc < 0)
471 return rc;
472
473 sgi->gtp_fd1u.fd = gsn->fd1u;
474 sgi->gtp_fd1u.priv_nr = 2;
475 sgi->gtp_fd1u.data = sgi;
Harald Welte322a5ee2010-05-18 13:13:11 +0200476 sgi->gtp_fd1u.when = BSC_FD_READ;
Harald Welte2720e732010-05-17 00:44:57 +0200477 sgi->gtp_fd1u.cb = sgsn_gtp_fd_cb;
478 bsc_register_fd(&sgi->gtp_fd1u);
479 if (rc < 0)
480 return rc;
481
482 /* Start GTP re-transmission timer */
483 sgi->gtp_timer.cb = sgsn_gtp_tmr_cb;
Harald Welte51537ee2010-05-18 18:28:13 +0200484 sgi->gtp_timer.data = sgi;
Harald Welte2720e732010-05-17 00:44:57 +0200485 sgsn_gtp_tmr_start(sgi);
486
487 /* Register callbackcs with libgtp */
488 gtp_set_cb_delete_context(gsn, cb_delete_context);
489 gtp_set_cb_conf(gsn, cb_conf);
490 gtp_set_cb_data_ind(gsn, cb_data_ind);
491 gtp_set_cb_unsup_ind(gsn, cb_unsup_ind);
492 gtp_set_cb_extheader_ind(gsn, cb_extheader_ind);
493
494 return 0;
495}