diff --git a/gtp/gtp.c b/gtp/gtp.c
index 7d36dbb..27d8a03 100644
--- a/gtp/gtp.c
+++ b/gtp/gtp.c
@@ -122,171 +122,162 @@
   return pdp_freepdp(pdp);
 }
 
-int gtp_create_context(struct gsn_t *gsn, struct pdp_t *pdp, void *aid,
-		       struct in_addr* inetaddr) {
-  int version = 0;
-
-  return gtp_create_pdp_req(gsn, version, aid, inetaddr, pdp);
-}
-
-int gtp_create_context2(struct gsn_t *gsn, void *aid, 
-			struct in_addr* inetaddr,
-			int selmode, uint64_t imsi, int nsapi,
-			uint8_t *qos, int qoslen,
-			char *apn, int apnlen,
-			char *msisdn, int msisdnlen,
-			uint8_t *pco, int pcolen) {
-  int version = 0;
-
-  struct pdp_t *pdp;
-
-  if (qoslen > sizeof(pdp->qos_req0)) {
-    gtp_err(LOG_ERR, __FILE__, __LINE__, 0, "QoS length too big");
-    return -1;
-  }
-
-  if (apnlen > sizeof(pdp->apn_use.v)) {
-    gtp_err(LOG_ERR, __FILE__, __LINE__, 0, "APN length too big");
-    return -1;
-  }
-
-  if (msisdnlen > sizeof(pdp->msisdn.v)) {
-    gtp_err(LOG_ERR, __FILE__, __LINE__, 0, "MSISDN length too big");
-    return -1;
-  }
-
-  if (pcolen > sizeof(pdp->pco_req.v)) {
-    gtp_err(LOG_ERR, __FILE__, __LINE__, 0, "PCO length too big");
-    return -1;
-  }
-
-  /* New pdp allocated here:*/
-  pdp_newpdp(&pdp, imsi, nsapi, NULL); 
-
-  pdp->peer = aid;
-  pdp->ipif = NULL;
-
-  pdp->selmode = selmode; 
-
-  memcpy(pdp->qos_req0, qos, qoslen);  /* Length checked above */
-  pdp->apn_use.l = apnlen;
-  memcpy(pdp->apn_use.v, apn, apnlen); /* Length checked above */
-
-  pdp->gsnlc.l = sizeof(gsn->gsnc);
-  memcpy(pdp->gsnlc.v, &gsn->gsnc, sizeof(gsn->gsnc));
-  pdp->gsnlu.l = sizeof(gsn->gsnc);
-  memcpy(pdp->gsnlu.v, &gsn->gsnc, sizeof(gsn->gsnc));
-
-  pdp->msisdn.l = msisdnlen;
-  memcpy(pdp->msisdn.v, msisdn, msisdnlen);
-
-  ipv42eua(&pdp->eua, NULL); /* Request dynamic IP address */
-
-  pdp->pco_req.l = pcolen;
-  memcpy(pdp->pco_req.v, pco, pcolen);
-
-  return gtp_create_pdp_req(gsn, version, aid, inetaddr, pdp);
-}
-
-int gtp_update_context(struct gsn_t *gsn, struct pdp_t *pdp, void *aid,
-		       struct in_addr* inetaddr) {
-  int version = 0;
-  
-  return gtp_update_pdp_req(gsn, version, aid, inetaddr, pdp);
-}
-
-int gtp_delete_context(struct gsn_t *gsn, struct pdp_t *pdp, void *aid) {
-  int version = 0;
-  return gtp_delete_pdp_req(gsn, version, aid, pdp);
-}
-
 /* gtp_gpdu */
 
 extern int gtp_fd(struct gsn_t *gsn) {
-  return gsn->fd;
+  return gsn->fd0;
 }
 
 /* gtp_decaps */
 /* gtp_retrans */
 /* gtp_retranstimeout */
 
+
+int gtp_set_cb_unsup_ind(struct gsn_t *gsn,
+			 int (*cb) (struct sockaddr_in *peer)) {
+  gsn->cb_unsup_ind = cb;
+  return 0;
+}
+
+
+/* API: Initialise delete context callback */
+/* Called whenever a pdp context is deleted for any reason */
 int gtp_set_cb_delete_context(struct gsn_t *gsn,
-			      int (*cb_delete_context) (struct pdp_t* pdp)) 
+      int (*cb) (struct pdp_t* pdp)) 
 {
-  gsn->cb_delete_context = cb_delete_context;
+  gsn->cb_delete_context = cb;
   return 0;
 }
 
-int gtp_set_cb_create_context(struct gsn_t *gsn,
-			      int (*cb_create_context) (struct pdp_t* pdp)) 
-{
-  gsn->cb_create_context = cb_create_context;
-  return 0;
-}
-
-/*
-
-  int gtp_set_cb_create_pdp_conf(struct gsn_t *gsn, 
-  int (*cb) (struct pdp_t*, int)) 
-  {
-   gsn->cb_create_pdp_conf = cb;
-  return 0;
-  }
-
- int gtp_set_cb_update_pdp_conf(struct gsn_t *gsn, 
-			       int (*cb) (struct pdp_t*, int, int)) 
- {
-   gsn->cb_update_pdp_conf = cb;
-   return 0;
-} 
-
-in t gtp_set_cb_delete_pdp_conf(struct gsn_t *gsn, 
-int (*cb) (struct pdp_t*, int)) 
- { 
-gsn->cb_delete_pdp_conf = cb;
-return 0;
-}
-
-*/
-
 int gtp_set_cb_conf(struct gsn_t *gsn,
 		    int (*cb) (int type, int cause, 
-			       struct pdp_t* pdp, void *aid)) {
+			       struct pdp_t* pdp, void *cbp)) {
   gsn->cb_conf = cb;
   return 0;
 }
 
-extern int gtp_set_cb_gpdu(struct gsn_t *gsn,
-			   int (*cb_gpdu) (struct pdp_t* pdp,
+extern int gtp_set_cb_data_ind(struct gsn_t *gsn,
+			   int (*cb_data_ind) (struct pdp_t* pdp,
 					   void* pack,
 					   unsigned len)) 
 {
-  gsn->cb_gpdu = cb_gpdu;
+  gsn->cb_data_ind = cb_data_ind;
   return 0;
 }
 
-
-void get_default_gtp(int version, void *packet) {
+/**
+ * get_default_gtp()
+ * Generate a GPRS Tunneling Protocol signalling packet header, depending
+ * on GTP version and message type. pdp is used for teid/flow label.
+ * *packet must be allocated by the calling function, and be large enough
+ * to hold the packet header.
+ * returns the length of the header. 0 on error.
+ **/
+static int get_default_gtp(int version, u_int8_t type, void *packet) {
   struct gtp0_header *gtp0_default = (struct gtp0_header*) packet;
   struct gtp1_header_long *gtp1_default = (struct gtp1_header_long*) packet;
   switch (version) {
   case 0:
     /* Initialise "standard" GTP0 header */
-    memset(gtp0_default, 0, sizeof(gtp0_default));
+    memset(gtp0_default, 0, sizeof(struct gtp0_header));
     gtp0_default->flags=0x1e;
+    gtp0_default->type=hton8(type);
     gtp0_default->spare1=0xff;
     gtp0_default->spare2=0xff;
     gtp0_default->spare3=0xff;
     gtp0_default->number=0xff;
-  break;
+    return GTP0_HEADER_SIZE;
   case 1:
     /* Initialise "standard" GTP1 header */
-    memset(gtp1_default, 0, sizeof(gtp1_default));
-    gtp0_default->flags=0x1e;
-    break;
+    /* 29.060: 8.2: S=1 and PN=0 */
+    /* 29.060 9.3.1: For GTP-U messages Echo Request, Echo Response */
+    /* and Supported Extension Headers Notification, the S field shall be */
+    /* set to 1 */
+    /* Currently extension headers are not supported */
+    memset(gtp1_default, 0, sizeof(struct gtp1_header_long));
+    gtp1_default->flags=0x32; /* No extension, enable sequence, no N-PDU */
+    gtp1_default->type=hton8(type);
+    return GTP1_HEADER_SIZE_LONG;
+  default:
+    gtp_err(LOG_ERR, __FILE__, __LINE__, "Unknown GTP packet version");
+    return 0;
   }
 }
 
+/**
+ * get_seq()
+ * Get sequence number of a packet.
+ * Returns 0 on error
+ **/
+static uint16_t get_seq(void *pack) {
+  union gtp_packet *packet = (union gtp_packet *) pack;
+
+  if ((packet->flags & 0xe0) == 0x00) { /* Version 0 */
+    return ntoh16(packet->gtp0.h.seq);
+  }
+  else if ((packet->flags & 0xe2) == 0x22) { /* Version 1 with seq */
+    return ntoh16(packet->gtp1l.h.seq);
+  } else {
+    gtp_err(LOG_ERR, __FILE__, __LINE__, "Unknown packet flag");
+    return 0;
+  }
+}
+
+/**
+ * get_tid()
+ * Get tunnel identifier of a packet.
+ * Returns 0 on error
+ **/
+static uint64_t get_tid(void *pack) {
+  union gtp_packet *packet = (union gtp_packet *) pack;
+  
+  if ((packet->flags & 0xe0) == 0x00) { /* Version 0 */
+    return packet->gtp0.h.tid;
+  }
+  return 0;
+}
+
+/**
+ * get_hlen()
+ * Get the header length of a packet.
+ * Returns 0 on error
+ **/
+static uint16_t get_hlen(void *pack) {
+  union gtp_packet *packet = (union gtp_packet *) pack;
+
+  if ((packet->flags & 0xe0) == 0x00) { /* Version 0 */
+    return GTP0_HEADER_SIZE;
+  }
+  else if ((packet->flags & 0xe2) == 0x22) { /* Version 1 with seq */
+    return GTP1_HEADER_SIZE_LONG;
+  }
+  else if ((packet->flags & 0xe7) == 0x20) { /* Short version 1 */
+    return GTP1_HEADER_SIZE_SHORT;
+  } else {
+    gtp_err(LOG_ERR, __FILE__, __LINE__, "Unknown packet flag");
+    return 0;
+  }
+}
+
+/**
+ * get_tei()
+ * Get the tunnel endpoint identifier (flow label) of a packet.
+ * Returns 0xffffffff on error.
+ **/
+static uint32_t get_tei(void *pack) {
+  union gtp_packet *packet = (union gtp_packet *) pack;
+
+  if ((packet->flags & 0xe0) == 0x00) { /* Version 0 */
+    return ntoh16(packet->gtp0.h.flow);
+  }
+  else if ((packet->flags & 0xe0) == 0x20) { /* Version 1 */
+    return ntoh32(packet->gtp1l.h.tei);
+  }
+  else {
+    gtp_err(LOG_ERR, __FILE__, __LINE__, "Unknown packet flag");
+    return 0xffffffff;
+  }
+}
 
 
 int print_packet(void *packet, unsigned len)
@@ -362,8 +353,8 @@
  * Create pdp context: The SGSN may send create context request even if
  *   a context allready exist (imsi+nsapi?). This means that the reply will
      automatically dublicate the original response. It might however have
- *   sideeffects in the application which is asked twice to allocate
- *   validate the login.
+ *   side effects in the application which is asked twice to validate
+ *   the login.
  * Update pdp context: Automatically dublicates the original response???
  * Delete pdp context. Automatically in gtp0, but in gtp1 will generate
  *   a nonexist reply message.
@@ -390,28 +381,57 @@
  * gtp_conf:
  *   Remove an incoming confirmation from the queue
  * gtp_resp:
- *   Send off a responce to a request. Use the same sequence
+ *   Send off a response to a request. Use the same sequence
  *   number in the response as in the request.
  * gtp_retrans:
  *   Retransmit any outstanding packets which have exceeded
  *   a predefined timeout.
  *************************************************************/
 
-int gtp_req(struct gsn_t *gsn, int version, union gtp_packet *packet, 
-	    int len, struct in_addr *inetaddr, void *aid) {
+int gtp_req(struct gsn_t *gsn, int version, struct pdp_t *pdp,
+	    union gtp_packet *packet, int len, 
+	    struct in_addr *inetaddr, void *cbp) {
   struct sockaddr_in addr;
   struct qmsg_t *qmsg;
+  int fd;
+
   memset(&addr, 0, sizeof(addr));
   addr.sin_family = AF_INET;
   addr.sin_addr = *inetaddr;
-  addr.sin_port = htons(GTP0_PORT);
 
-  packet->gtp0.h.seq = hton16(gsn->seq_next);
+  if ((packet->flags & 0xe0) == 0x00) { /* Version 0 */
+    addr.sin_port = htons(GTP0_PORT);
+    packet->gtp0.h.length = hton16(len - GTP0_HEADER_SIZE);
+    packet->gtp0.h.seq = hton16(gsn->seq_next);
+    if (pdp)
+      packet->gtp0.h.tid = (pdp->imsi & 0x0fffffffffffffff) + 
+	((uint64_t)pdp->nsapi << 60);
+    if (pdp && ((packet->gtp0.h.type == GTP_GPDU) ||
+		(packet->gtp0.h.type == GTP_ERROR)))
+      packet->gtp0.h.flow=hton16(pdp->flru);
+    else if (pdp)
+      packet->gtp0.h.flow=hton16(pdp->flrc);
+    fd = gsn->fd0;
+  }
+  else if ((packet->flags & 0xe2) == 0x22) { /* Version 1 with seq */
+    addr.sin_port = htons(GTP1C_PORT);
+    packet->gtp1l.h.length = hton16(len - GTP1_HEADER_SIZE_SHORT);
+    packet->gtp1l.h.seq = hton16(gsn->seq_next);
+    if (pdp && ((packet->gtp1l.h.type == GTP_GPDU) ||
+		(packet->gtp1l.h.type == GTP_ERROR)))
+      packet->gtp1l.h.tei=hton32(pdp->teid_gn);
+    else if (pdp)
+      packet->gtp1l.h.tei=hton32(pdp->teic_gn);
+    fd = gsn->fd1c;
+  } else {
+    gtp_err(LOG_ERR, __FILE__, __LINE__, "Unknown packet flag");
+    return -1;
+  }
   
-  if (sendto(gsn->fd, packet, len, 0,
+  if (sendto(fd, packet, len, 0,
 	     (struct sockaddr *) &addr, sizeof(addr)) < 0) {
     gsn->err_sendto++;
-    gtp_err(LOG_ERR, __FILE__, __LINE__, "Sendto(fd=%d, msg=%lx, len=%d) failed: Error = %s", gsn->fd, (unsigned long) &packet, len, strerror(errno));
+    gtp_err(LOG_ERR, __FILE__, __LINE__, "Sendto(fd=%d, msg=%lx, len=%d) failed: Error = %s", fd, (unsigned long) &packet, len, strerror(errno));
     return -1;
   }
 
@@ -425,8 +445,9 @@
     qmsg->l = len;
     qmsg->timeout = time(NULL) + 3; /* When to timeout */
     qmsg->retrans = 0;   /* No retransmissions so far */
-    qmsg->aid = aid;
+    qmsg->cbp = cbp;
     qmsg->type = ntoh8(packet->gtp0.h.type);
+    qmsg->fd = fd;
   }
   gsn->seq_next++; /* Count up this time */
   return 0;
@@ -437,10 +458,21 @@
  * return 0 on success, EOF if packet was not found */
 
 int gtp_conf(struct gsn_t *gsn, int version, struct sockaddr_in *peer,
-	     union gtp_packet *packet, int len, uint8_t *type, void **aid) {
-  int seq = ntoh16(packet->gtp0.h.seq);
+	     union gtp_packet *packet, int len, uint8_t *type, void **cbp) {
 
-  if (queue_freemsg_seq(gsn->queue_req, peer, seq, type, aid)) {
+  uint16_t seq;
+
+  if ((packet->gtp0.h.flags & 0xe0) == 0x00)
+    seq = ntoh16(packet->gtp0.h.seq);
+  else if ((packet->gtp1l.h.flags & 0xe2) == 0x22)
+    seq = ntoh16(packet->gtp1l.h.seq);
+  else {
+    gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, packet, len,
+		"Unknown GTP packet version");
+    return EOF;
+  }
+
+  if (queue_freemsg_seq(gsn->queue_req, peer, seq, type, cbp)) {
     gsn->err_seq++;
     gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, packet, len,
 		"Confirmation packet not found in queue");
@@ -462,14 +494,14 @@
 	 (qmsg->timeout <= now)) {
     /*printf("Retrans timeout found: %d\n", (int) time(NULL));*/
     if (qmsg->retrans > 3) { /* To many retrans */
-      if (gsn->cb_conf) gsn->cb_conf(qmsg->type, EOF, NULL, qmsg->aid);
+      if (gsn->cb_conf) gsn->cb_conf(qmsg->type, EOF, NULL, qmsg->cbp);
       queue_freemsg(gsn->queue_req, qmsg);
     }
     else {
-      if (sendto(gsn->fd, &qmsg->p, qmsg->l, 0,
+      if (sendto(qmsg->fd, &qmsg->p, qmsg->l, 0,
 		 (struct sockaddr *) &qmsg->peer, sizeof(struct sockaddr_in)) < 0) {
 	gsn->err_sendto++;
-	gtp_err(LOG_ERR, __FILE__, __LINE__, "Sendto(fd=%d, msg=%lx, len=%d) failed: Error = %s", gsn->fd, (unsigned long) &qmsg->p, qmsg->l, strerror(errno));
+	gtp_err(LOG_ERR, __FILE__, __LINE__, "Sendto(fd0=%d, msg=%lx, len=%d) failed: Error = %s", gsn->fd0, (unsigned long) &qmsg->p, qmsg->l, strerror(errno));
       }
       queue_back(gsn->queue_req, qmsg);
       qmsg->timeout = now + 3;
@@ -506,30 +538,44 @@
   return 0;
 }
 
-int gtp_resp(int version, struct gsn_t *gsn, union gtp_packet *packet,
-	     int len, struct sockaddr_in *peer) {
+int gtp_resp(int version, struct gsn_t *gsn, struct pdp_t *pdp, 
+	     union gtp_packet *packet, int len,
+	     struct sockaddr_in *peer, int fd, 
+	     uint16_t seq, uint64_t tid) {
   struct qmsg_t *qmsg;
-  uint16_t seq;
 
-  seq = ntoh16(packet->gtp0.h.seq);
-  
-  /* print message */
-  /*
-  printf("gtp_resp: to %s:UDP%u\n",
-	 inet_ntoa(peer->sin_addr),
-	 ntohs(peer->sin_port));
-  print_packet(packet, len); 
-  */
-
-  if (fcntl(gsn->fd, F_SETFL, 0)) {
-    gtp_err(LOG_ERR, __FILE__, __LINE__, "fnctl()");
+  if ((packet->flags & 0xe0) == 0x00) { /* Version 0 */
+    packet->gtp0.h.length = hton16(len - GTP0_HEADER_SIZE);
+    packet->gtp0.h.seq = hton16(seq);
+    packet->gtp0.h.tid = tid;
+    if (pdp && ((packet->gtp0.h.type == GTP_GPDU) ||
+		(packet->gtp0.h.type == GTP_ERROR)))
+      packet->gtp0.h.flow=hton16(pdp->flru);
+    else if (pdp)
+      packet->gtp0.h.flow=hton16(pdp->flrc);
+  }
+  else if ((packet->flags & 0xe2) == 0x22) { /* Version 1 with seq */
+    packet->gtp1l.h.length = hton16(len - GTP1_HEADER_SIZE_SHORT);
+    packet->gtp1l.h.seq = hton16(seq);
+    if (pdp && (fd == gsn->fd1u))
+      packet->gtp1l.h.tei=hton32(pdp->teid_gn);
+    else if (pdp)
+      packet->gtp1l.h.tei=hton32(pdp->teic_gn);
+  }
+  else {
+    gtp_err(LOG_ERR, __FILE__, __LINE__, "Unknown packet flag");
     return -1;
   }
   
-  if (sendto(gsn->fd, packet, len, 0,
+  if (fcntl(fd, F_SETFL, 0)) {
+    gtp_err(LOG_ERR, __FILE__, __LINE__, "fnctl()");
+    return -1;
+  }
+
+  if (sendto(fd, packet, len, 0,
 	     (struct sockaddr *) peer, sizeof(struct sockaddr_in)) < 0) {
     gsn->err_sendto++;
-    gtp_err(LOG_ERR, __FILE__, __LINE__, "Sendto(fd=%d, msg=%lx, len=%d) failed: Error = %s", gsn->fd, (unsigned long) &packet, len, strerror(errno));
+    gtp_err(LOG_ERR, __FILE__, __LINE__, "Sendto(fd=%d, msg=%lx, len=%d) failed: Error = %s", fd, (unsigned long) &packet, len, strerror(errno));
     return -1;
   }
 
@@ -543,8 +589,9 @@
     qmsg->l = len;
     qmsg->timeout = time(NULL) + 60; /* When to timeout */
     qmsg->retrans = 0;   /* No retransmissions so far */
-    qmsg->aid = NULL;
+    qmsg->cbp = NULL;
     qmsg->type = 0;
+    qmsg->fd = fd;
   }
   return 0;
 }
@@ -556,27 +603,18 @@
   if(queue_seqget(gsn->queue_resp, &qmsg, peer, seq)) {
     return EOF; /* Notfound */
   }
-  else {
-    /* print message */
-    
-    /*printf("gtp_dublicate: to %s:UDP%u\n",
-	   inet_ntoa(peer->sin_addr),
-	   ntohs(peer->sin_port));
-    print_packet(&qmsg->p, qmsg->l);
-    */
 
-    if (fcntl(gsn->fd, F_SETFL, 0)) {
-      gtp_err(LOG_ERR, __FILE__, __LINE__, "fnctl()");
-      return -1;
-    }
-
-    if (sendto(gsn->fd, &qmsg->p, qmsg->l, 0,
-	       (struct sockaddr *) peer, sizeof(struct sockaddr_in)) < 0) {
-      gsn->err_sendto++;
-      gtp_err(LOG_ERR, __FILE__, __LINE__, "Sendto(fd=%d, msg=%lx, len=%d) failed: Error = %s", gsn->fd, (unsigned long) &qmsg->p, qmsg->l, strerror(errno));
-    }
-    return 0;
+  if (fcntl(qmsg->fd, F_SETFL, 0)) {
+    gtp_err(LOG_ERR, __FILE__, __LINE__, "fnctl()");
+    return -1;
   }
+  
+  if (sendto(qmsg->fd, &qmsg->p, qmsg->l, 0,
+	     (struct sockaddr *) peer, sizeof(struct sockaddr_in)) < 0) {
+    gsn->err_sendto++;
+    gtp_err(LOG_ERR, __FILE__, __LINE__, "Sendto(fd=%d, msg=%lx, len=%d) failed: Error = %s", qmsg->fd, (unsigned long) &qmsg->p, qmsg->l, strerror(errno));
+  }
+  return 0;
 }
 
 
@@ -629,7 +667,6 @@
 	    int mode) 
 {
   struct sockaddr_in addr;
-  int gtp_fd;
   
   syslog(LOG_ERR, "GTP: gtp_newgsn() started");
 
@@ -649,33 +686,69 @@
   pdp_init();
 
   /* Initialise call back functions */
-  (*gsn)->cb_create_context = 0;
+  (*gsn)->cb_create_context_ind = 0;
   (*gsn)->cb_delete_context = 0;
+  (*gsn)->cb_unsup_ind = 0;
   (*gsn)->cb_conf = 0;
-  (*gsn)->cb_gpdu = 0;
+  (*gsn)->cb_data_ind = 0;
 
-  if ((gtp_fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0 ) {
+  /* Store function parameters */
+  (*gsn)->gsnc = *listen;
+  (*gsn)->gsnu = *listen;
+  (*gsn)->mode = mode;
+
+
+  /* Create GTP version 0 socket */
+  if (((*gsn)->fd0 = socket(AF_INET, SOCK_DGRAM, 0)) < 0 ) {
     (*gsn)->err_socket++;
     gtp_err(LOG_ERR, __FILE__, __LINE__, "socket(domain=%d, type=%d, protocol=%d) failed: Error = %s", AF_INET, SOCK_DGRAM, 0, strerror(errno));
     return -1;
   }
-  (*gsn)->fd = gtp_fd;
-
-  (*gsn)->gsnc = *listen;
-  (*gsn)->gsnu = *listen;
-
-  (*gsn)->mode = mode;
     
   memset(&addr, 0, sizeof(addr));
-  
   addr.sin_family = AF_INET;
-  /*  addr.sin_addr = *inetaddr; */
   addr.sin_addr = *listen;  /* Same IP for user traffic and signalling*/
   addr.sin_port = htons(GTP0_PORT);
   
-  if (bind(gtp_fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
+  if (bind((*gsn)->fd0, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
     (*gsn)->err_socket++;
-    gtp_err(LOG_ERR, __FILE__, __LINE__, "bind(fd=%d, addr=%lx, len=%d) failed: Error = %s", gtp_fd, (unsigned long) &addr, sizeof(addr), strerror(errno));
+    gtp_err(LOG_ERR, __FILE__, __LINE__, "bind(fd0=%d, addr=%lx, len=%d) failed: Error = %s", (*gsn)->fd0, (unsigned long) &addr, sizeof(addr), strerror(errno));
+    return -1;
+  }
+
+  /* Create GTP version 1 control plane socket */
+  if (((*gsn)->fd1c = socket(AF_INET, SOCK_DGRAM, 0)) < 0 ) {
+    (*gsn)->err_socket++;
+    gtp_err(LOG_ERR, __FILE__, __LINE__, "socket(domain=%d, type=%d, protocol=%d) failed: Error = %s", AF_INET, SOCK_DGRAM, 0, strerror(errno));
+    return -1;
+  }
+
+  memset(&addr, 0, sizeof(addr));
+  addr.sin_family = AF_INET;
+  addr.sin_addr = *listen;  /* Same IP for user traffic and signalling*/
+  addr.sin_port = htons(GTP1C_PORT);
+  
+  if (bind((*gsn)->fd1c, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
+    (*gsn)->err_socket++;
+    gtp_err(LOG_ERR, __FILE__, __LINE__, "bind(fd1c=%d, addr=%lx, len=%d) failed: Error = %s", (*gsn)->fd1c, (unsigned long) &addr, sizeof(addr), strerror(errno));
+    return -1;
+  }
+
+  /* Create GTP version 1 user plane socket */
+  if (((*gsn)->fd1u = socket(AF_INET, SOCK_DGRAM, 0)) < 0 ) {
+    (*gsn)->err_socket++;
+    gtp_err(LOG_ERR, __FILE__, __LINE__, "socket(domain=%d, type=%d, protocol=%d) failed: Error = %s", AF_INET, SOCK_DGRAM, 0, strerror(errno));
+    return -1;
+  }
+
+  memset(&addr, 0, sizeof(addr));
+  addr.sin_family = AF_INET;
+  addr.sin_addr = *listen;  /* Same IP for user traffic and signalling*/
+  addr.sin_port = htons(GTP1U_PORT);
+  
+  if (bind((*gsn)->fd1u, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
+    (*gsn)->err_socket++;
+    gtp_err(LOG_ERR, __FILE__, __LINE__, "bind(fd1c=%d, addr=%lx, len=%d) failed: Error = %s", (*gsn)->fd1c, (unsigned long) &addr, sizeof(addr), strerror(errno));
     return -1;
   }
 
@@ -687,6 +760,10 @@
   /* Clean up retransmit queues */
   queue_free(gsn->queue_req);
   queue_free(gsn->queue_resp);
+  
+  close(gsn->fd0);
+  close(gsn->fd1c);
+  close(gsn->fd1u);
 
   free(gsn);
   return 0;
@@ -722,67 +799,56 @@
  *************************************************************/
 
 /* Send off an echo request */
-int gtp_echo_req(struct gsn_t *gsn, struct in_addr *inetaddr)
+int gtp_echo_req(struct gsn_t *gsn, int version, void *cbp,
+		 struct in_addr *inetaddr)
 {
   union gtp_packet packet;
-
-  get_default_gtp(0, &packet);
-  packet.gtp0.h.type = hton8(GTP_ECHO_REQ);
-  packet.gtp0.h.length = hton16(0);
-
-  return gtp_req(gsn, 0, &packet, GTP0_HEADER_SIZE, inetaddr, NULL);
+  int length = get_default_gtp(version, GTP_ECHO_REQ, &packet);
+  return gtp_req(gsn, version, NULL, &packet, length, inetaddr, cbp);
 }
 
-/* Send of an echo reply */
-int gtp_echo_resp(struct gsn_t *gsn, struct sockaddr_in *peer,
+/* Send off an echo reply */
+int gtp_echo_resp(struct gsn_t *gsn, int version,
+		  struct sockaddr_in *peer, int fd,
 		  void *pack, unsigned len)
 {
   union gtp_packet packet;
-  int length = 0;
-  
-  get_default_gtp(0, &packet);
-
-  gtpie_tv1(packet.gtp0.p, &length, GTP_MAX, GTPIE_RECOVERY, 
-	    gsn->restart_counter);
-  
-  packet.gtp0.h.type = hton8(GTP_ECHO_RSP);
-  packet.gtp0.h.length = hton16(length);
-  packet.gtp0.h.seq = ((union gtp_packet*)pack)->gtp0.h.seq;
-
-  return gtp_resp(0, gsn, &packet, GTP0_HEADER_SIZE+length, peer);
+  int length = get_default_gtp(version, GTP_ECHO_RSP, &packet);
+  gtpie_tv1(&packet, &length, GTP_MAX, GTPIE_RECOVERY, gsn->restart_counter);
+  return gtp_resp(version, gsn, NULL, &packet, length, peer, fd, 
+		  get_seq(pack), get_tid(pack));
 }
 
 
 /* Handle a received echo request */
-int gtp_echo_ind(struct gsn_t *gsn, struct sockaddr_in *peer,
-		 void *pack, unsigned len) {
+int gtp_echo_ind(struct gsn_t *gsn, int version, struct sockaddr_in *peer, 
+		 int fd, void *pack, unsigned len) {
 
-  uint16_t seq = ntoh16(((union gtp_packet*)pack)->gtp0.h.seq);
+  /* Check if it was a dublicate request */
+  if(!gtp_dublicate(gsn, 0, peer, get_seq(pack))) return 0;
 
-  if(!gtp_dublicate(gsn, 0, peer, seq)) {
-    return 0; /* We allready send of response once */
-  }
-
-
-  /* Now send off a reply to the peer */
-  return gtp_echo_resp(gsn, peer, pack, len);
+  /* Send off reply to request */
+  return gtp_echo_resp(gsn, version, peer, fd, pack, len);
 }
 
 /* Handle a received echo reply */
-int gtp_echo_conf(struct gsn_t *gsn, struct sockaddr_in *peer,
+int gtp_echo_conf(struct gsn_t *gsn, int version, struct sockaddr_in *peer,
 		  void *pack, unsigned len) {
   union gtpie_member *ie[GTPIE_SIZE];
   unsigned char recovery;
-  void *aid = NULL;
+  void *cbp = NULL;
   uint8_t type = 0;
+  int hlen = get_hlen(pack);
 
   /* Remove packet from queue */
-  if (gtp_conf(gsn, 0, peer, pack, len, &type, &aid)) return EOF;
+  if (gtp_conf(gsn, version, peer, pack, len, &type, &cbp)) return EOF;
 
-  if (gtpie_decaps(ie, pack+sizeof(struct gtp0_header), len-sizeof(struct gtp0_header))) {
+  /* Extract information elements into a pointer array */
+  if (gtpie_decaps(ie, version, pack+hlen, len-hlen)) {
     gsn->invalid++;
     gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		"Invalid message format");
+    if (gsn->cb_conf) gsn->cb_conf(type, EOF, NULL, cbp);
     return EOF;
   }
   
@@ -790,10 +856,13 @@
     gsn->missing++;
     gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		"Missing mandatory field");
+    if (gsn->cb_conf) gsn->cb_conf(type, EOF, NULL, cbp);
     return EOF;
   }
 
-  if (gsn->cb_conf) gsn->cb_conf(type, 0, NULL, aid); /* TODO: Should return recovery in callback */
+  /* Echo reply packages does not have a cause information element */
+  /* Instead we return the recovery number in the callback function */
+  if (gsn->cb_conf) gsn->cb_conf(type, recovery, NULL, cbp);
 
   return 0;
 }
@@ -809,34 +878,22 @@
  * only listen to the GTP0 port, and therefore will never receive
  * anything else than GTP0 */
 
-int gtp_unsup_resp(struct gsn_t *gsn, struct sockaddr_in *peer,
-		   void *pack, unsigned len)
+int gtp_unsup_req(struct gsn_t *gsn, int version, struct sockaddr_in *peer,
+		  int fd, void *pack, unsigned len)
 {
   union gtp_packet packet;
-  int length = 0;
 
-  get_default_gtp(0, &packet);
-  packet.gtp0.h.type = hton8(GTP_NOT_SUPPORTED);
-  packet.gtp0.h.length = hton16(0);
-  
-  return gtp_resp(0, gsn, &packet, GTP0_HEADER_SIZE+length, peer);
+  /* GTP 1 is the highest supported protocol */
+  int hlen = get_default_gtp(1, GTP_NOT_SUPPORTED, &packet);
+  return gtp_resp(version, gsn, NULL, &packet, hlen, peer, fd, 0, 0);
 }
 
 /* Handle a Version Not Supported message */
-int gtp_unsup_conf(struct gsn_t *gsn, struct sockaddr_in *peer, void *pack, unsigned len) {
+int gtp_unsup_ind(struct gsn_t *gsn, struct sockaddr_in *peer, 
+		  void *pack, unsigned len) {
 
-  /* TODO: Need to check the validity of header and information elements */
-  /* TODO: Implement callback to application */
-  /* As long as we only support GTP0 we should never receive this message */
-  /* Should be implemented as part of GTP1 support */
+  if (gsn->cb_unsup_ind) gsn->cb_unsup_ind(peer);
   
-  /* print received message */
-  /*
-  printf("gtp_unsup_ind: from %s:UDP%u\n",
-	 inet_ntoa(peer->sin_addr),
-	 ntohs(peer->sin_port));
-  print_packet(pack, len);
-  */
   return 0;
 }
 
@@ -852,284 +909,404 @@
  * information.
  *************************************************************/
 
-/* Send Create PDP Context Request */
-extern int gtp_create_pdp_req(struct gsn_t *gsn, int version, void *aid,
-			      struct in_addr* inetaddr, struct pdp_t *pdp) {
+/* API: Send Create PDP Context Request */
+extern int gtp_create_context_req(struct gsn_t *gsn, struct pdp_t *pdp, 
+				  void *cbp, struct in_addr* inetaddr) {
   union gtp_packet packet;
-  int length = 0;
+  int length = get_default_gtp(pdp->version, GTP_CREATE_PDP_REQ, &packet);
 
-  get_default_gtp(0, &packet);
-  
-  if (0==0) { /* Always GTP0 */
-
-    gtpie_tv0(packet.gtp0.p, &length, GTP_MAX, GTPIE_QOS_PROFILE0, 
+  if (pdp->version == 0)
+    gtpie_tv0(&packet, &length, GTP_MAX, GTPIE_QOS_PROFILE0, 
 	      sizeof(pdp->qos_req0), pdp->qos_req0);
-    gtpie_tv1(packet.gtp0.p, &length, GTP_MAX, GTPIE_RECOVERY, 
-	      gsn->restart_counter);
-    gtpie_tv1(packet.gtp0.p, &length, GTP_MAX, GTPIE_SELECTION_MODE,
-	      pdp->selmode);
-    gtpie_tv2(packet.gtp0.p, &length, GTP_MAX, GTPIE_FL_DI, 
-	      pdp->fllu);
-    gtpie_tv2(packet.gtp0.p, &length, GTP_MAX, GTPIE_FL_C,
-	      pdp->fllc);
-    gtpie_tlv(packet.gtp0.p, &length, GTP_MAX, GTPIE_EUA, 
-	      pdp->eua.l, pdp->eua.v);
-    gtpie_tlv(packet.gtp0.p, &length, GTP_MAX, GTPIE_APN, 
-	      pdp->apn_use.l, pdp->apn_use.v);
 
-    if (pdp->pco_req.l) { /* Optional PCO */
-      gtpie_tlv(packet.gtp0.p, &length, GTP_MAX, GTPIE_PCO, 
-		pdp->pco_req.l, pdp->pco_req.v);
-    }
-
-    gtpie_tlv(packet.gtp0.p, &length, GTP_MAX, GTPIE_GSN_ADDR, 
-	      pdp->gsnlc.l, pdp->gsnlc.v);
-    gtpie_tlv(packet.gtp0.p, &length, GTP_MAX, GTPIE_GSN_ADDR, 
-	      pdp->gsnlu.l, pdp->gsnlu.v);
-    gtpie_tlv(packet.gtp0.p, &length, GTP_MAX, GTPIE_MSISDN,
-	      pdp->msisdn.l, pdp->msisdn.v);
-    
-
-
-  } else { /* GTP1 */
-    gtpie_tv0(packet.gtp1s.p, &length, GTP_MAX, GTPIE_IMSI, 
+  if (pdp->version == 1)
+    gtpie_tv0(&packet, &length, GTP_MAX, GTPIE_IMSI, 
 	      sizeof(pdp->imsi), (uint8_t*) &pdp->imsi);
-    gtpie_tv1(packet.gtp1s.p, &length, GTP_MAX, GTPIE_RECOVERY, 
-	      gsn->restart_counter);
-    gtpie_tv1(packet.gtp1s.p, &length, GTP_MAX, GTPIE_SELECTION_MODE,
-	      pdp->selmode);
-    gtpie_tv4(packet.gtp1s.p, &length, GTP_MAX, GTPIE_TEI_DI, 
-	      pdp->teid_own);
-    gtpie_tv4(packet.gtp1s.p, &length, GTP_MAX, GTPIE_TEI_C,
-	      pdp->teic_own);
-    gtpie_tv1(packet.gtp1s.p, &length, GTP_MAX, GTPIE_NSAPI, 
-	      pdp->nsapi);
-    /*gtpie_tv1(packet.gtp1s.p, &length, GTP_MAX, GTPIE_NSAPI, 
-      pdp->nsapil); For use by several QoS profiles for the same address */
-    gtpie_tv2(packet.gtp1s.p, &length, GTP_MAX, GTPIE_CHARGING_C,
-	      pdp->cch_pdp);
-    gtpie_tv2(packet.gtp1s.p, &length, GTP_MAX, GTPIE_TRACE_REF,
-	      pdp->traceref);
-    gtpie_tv2(packet.gtp1s.p, &length, GTP_MAX, GTPIE_TRACE_TYPE,
-	      pdp->tracetype);
-    gtpie_tlv(packet.gtp1s.p, &length, GTP_MAX, GTPIE_EUA, 
-	      pdp->eua.l, pdp->eua.v);
-    gtpie_tlv(packet.gtp1s.p, &length, GTP_MAX, GTPIE_APN, 
-	      pdp->apn_use.l, pdp->apn_use.v);
-    gtpie_tlv(packet.gtp1s.p, &length, GTP_MAX, GTPIE_PCO, 
-	      pdp->pco_req.l, pdp->pco_req.v);
-    gtpie_tlv(packet.gtp1s.p, &length, GTP_MAX, GTPIE_GSN_ADDR, 
-	      pdp->gsnlc.l, pdp->gsnlc.v);
-    gtpie_tlv(packet.gtp1s.p, &length, GTP_MAX, GTPIE_GSN_ADDR, 
-	      pdp->gsnlu.l, pdp->gsnlu.v);
-    gtpie_tlv(packet.gtp1s.p, &length, GTP_MAX, GTPIE_MSISDN,
-	      pdp->msisdn.l, pdp->msisdn.v);
-    gtpie_tlv(packet.gtp1s.p, &length, GTP_MAX, GTPIE_QOS_PROFILE,
-	      pdp->qos_req.l, pdp->qos_req.v);
-    gtpie_tlv(packet.gtp1s.p, &length, GTP_MAX, GTPIE_TFT,
-	      pdp->tft.l, pdp->tft.v);
-    gtpie_tlv(packet.gtp1s.p, &length, GTP_MAX, GTPIE_TRIGGER_ID,
-	      pdp->triggerid.l, pdp->triggerid.v);
-    gtpie_tlv(packet.gtp1s.p, &length, GTP_MAX, GTPIE_OMC_ID,
-	      pdp->omcid.l, pdp->omcid.v);
-  }
-  packet.gtp0.h.type = hton8(GTP_CREATE_PDP_REQ);
-  packet.gtp0.h.length = hton16(length);
-  packet.gtp0.h.flow = 0;
-  packet.gtp0.h.tid = pdp->tid;
 
-  gtp_req(gsn, 0, &packet, GTP0_HEADER_SIZE+length, inetaddr, aid);
+  gtpie_tv1(&packet, &length, GTP_MAX, GTPIE_RECOVERY, 
+	    gsn->restart_counter);
+  gtpie_tv1(&packet, &length, GTP_MAX, GTPIE_SELECTION_MODE,
+	    pdp->selmode);
+
+  if (pdp->version == 0) {
+    gtpie_tv2(&packet, &length, GTP_MAX, GTPIE_FL_DI, 
+	      pdp->fllu);
+    gtpie_tv2(&packet, &length, GTP_MAX, GTPIE_FL_C,
+	      pdp->fllc);
+  }
+
+  if (pdp->version == 1) {
+    gtpie_tv4(&packet, &length, GTP_MAX, GTPIE_TEI_DI,
+	      pdp->teid_own);
+    gtpie_tv4(&packet, &length, GTP_MAX, GTPIE_TEI_C,
+	      pdp->teic_own);
+  }
+
+  gtpie_tv1(&packet, &length, GTP_MAX, GTPIE_NSAPI, 
+	    pdp->nsapi);
+
+  /*gtpie_tv1(packet.gtp1l.p, &length, GTP_MAX, GTPIE_NSAPI, 
+    pdp->nsapil); For use by several QoS profiles for the same address */
+
+  if (pdp->version == 1) {
+    gtpie_tv2(&packet, &length, GTP_MAX, GTPIE_CHARGING_C,
+	      pdp->cch_pdp);
+  }
+
+  /* TODO 
+  gtpie_tv2(&packet, &length, GTP_MAX, GTPIE_TRACE_REF,
+	    pdp->traceref);
+  gtpie_tv2(&packet, &length, GTP_MAX, GTPIE_TRACE_TYPE,
+	    pdp->tracetype); */
+
+  gtpie_tlv(&packet, &length, GTP_MAX, GTPIE_EUA, 
+	    pdp->eua.l, pdp->eua.v);
+  gtpie_tlv(&packet, &length, GTP_MAX, GTPIE_APN, 
+	    pdp->apn_use.l, pdp->apn_use.v);
+
+  if (pdp->pco_req.l)
+    gtpie_tlv(&packet, &length, GTP_MAX, GTPIE_PCO, 
+	      pdp->pco_req.l, pdp->pco_req.v);
+  
+  gtpie_tlv(&packet, &length, GTP_MAX, GTPIE_GSN_ADDR, 
+	    pdp->gsnlc.l, pdp->gsnlc.v);
+  gtpie_tlv(&packet, &length, GTP_MAX, GTPIE_GSN_ADDR, 
+	    pdp->gsnlu.l, pdp->gsnlu.v);
+  gtpie_tlv(&packet, &length, GTP_MAX, GTPIE_MSISDN,
+	    pdp->msisdn.l, pdp->msisdn.v);
+
+  if (pdp->version == 1) 
+    gtpie_tlv(&packet, &length, GTP_MAX, GTPIE_QOS_PROFILE,
+	      pdp->qos_req.l, pdp->qos_req.v);
+
+
+  if ((pdp->version == 1) && pdp->tft.l)
+    gtpie_tlv(&packet, &length, GTP_MAX, GTPIE_TFT,
+	      pdp->tft.l, pdp->tft.v);
+  
+  if ((pdp->version == 1) && pdp->triggerid.l)
+    gtpie_tlv(&packet, &length, GTP_MAX, GTPIE_TRIGGER_ID,
+	      pdp->triggerid.l, pdp->triggerid.v);
+  
+  if ((pdp->version == 1) && pdp->omcid.l)
+    gtpie_tlv(&packet, &length, GTP_MAX, GTPIE_OMC_ID,
+	      pdp->omcid.l, pdp->omcid.v);
+  
+  gtp_req(gsn, pdp->version, pdp, &packet, length, inetaddr, cbp);
 
   return 0;
 }
 
-/* Send Create PDP Context Response */
-int gtp_create_pdp_resp(struct gsn_t *gsn, int version,
-			struct sockaddr_in *peer, 
-			void *pack, unsigned len, 
-			struct pdp_t *pdp, uint8_t cause)
+
+/* API: Application response to context indication */
+int gtp_create_context_resp(struct gsn_t *gsn, struct pdp_t *pdp, int cause) {
+
+  /* Now send off a reply to the peer */
+  gtp_create_pdp_resp(gsn, pdp->version, pdp, cause);
+ 
+  if (cause != GTPCAUSE_ACC_REQ) {
+    pdp_freepdp(pdp);
+  }
+  
+  return 0;
+}
+
+/* API: Register create context indication callback */
+int gtp_set_cb_create_context_ind(struct gsn_t *gsn,
+      int (*cb_create_context_ind) (struct pdp_t* pdp)) 
 {
+  gsn->cb_create_context_ind = cb_create_context_ind;
+  return 0;
+}
+
+
+/* Send Create PDP Context Response */
+int gtp_create_pdp_resp(struct gsn_t *gsn, int version, struct pdp_t *pdp, 
+			uint8_t cause) {
   union gtp_packet packet;
-  int length = 0;
+  int length = get_default_gtp(version, GTP_CREATE_PDP_RSP, &packet);
 
-  get_default_gtp(0, &packet);
-
-  gtpie_tv1(packet.gtp0.p, &length, GTP_MAX, GTPIE_CAUSE, cause);
+  gtpie_tv1(&packet, &length, GTP_MAX, GTPIE_CAUSE, cause);
 
   if (cause == GTPCAUSE_ACC_REQ) {
-    gtpie_tv0(packet.gtp0.p, &length, GTP_MAX, GTPIE_QOS_PROFILE0, 
-	      sizeof(pdp->qos_neg0), pdp->qos_neg0);
-    gtpie_tv1(packet.gtp0.p, &length, GTP_MAX, GTPIE_REORDER,
+
+    if (version == 0) 
+      gtpie_tv0(&packet, &length, GTP_MAX, GTPIE_QOS_PROFILE0, 
+		sizeof(pdp->qos_neg0), pdp->qos_neg0);
+
+    gtpie_tv1(&packet, &length, GTP_MAX, GTPIE_REORDER,
 	      pdp->reorder);
-    gtpie_tv1(packet.gtp0.p, &length, GTP_MAX, GTPIE_RECOVERY, 
+    gtpie_tv1(&packet, &length, GTP_MAX, GTPIE_RECOVERY, 
 	      gsn->restart_counter);
-    gtpie_tv2(packet.gtp0.p, &length, GTP_MAX, GTPIE_FL_DI, 
-	      pdp->fllu);
-    gtpie_tv2(packet.gtp0.p, &length, GTP_MAX, GTPIE_FL_C,
-	      pdp->fllc);
-    gtpie_tv4(packet.gtp0.p, &length, GTP_MAX, GTPIE_CHARGING_ID,
+
+    if (version == 0) {
+      gtpie_tv2(&packet, &length, GTP_MAX, GTPIE_FL_DI, 
+		pdp->fllu);
+      gtpie_tv2(&packet, &length, GTP_MAX, GTPIE_FL_C,
+		pdp->fllc);
+    }
+
+    if (version == 1) {
+      gtpie_tv4(&packet, &length, GTP_MAX, GTPIE_TEI_DI, 
+		pdp->teid_own);
+      gtpie_tv4(&packet, &length, GTP_MAX, GTPIE_TEI_C,
+		pdp->teic_own);
+    }
+
+    gtpie_tv4(&packet, &length, GTP_MAX, GTPIE_CHARGING_ID,
 	      0x12345678);
-    gtpie_tlv(packet.gtp0.p, &length, GTP_MAX, GTPIE_EUA, 
+    gtpie_tlv(&packet, &length, GTP_MAX, GTPIE_EUA, 
 	      pdp->eua.l, pdp->eua.v);
 
     if (pdp->pco_neg.l) { /* Optional PCO */
-      gtpie_tlv(packet.gtp0.p, &length, GTP_MAX, GTPIE_PCO,
+      gtpie_tlv(&packet, &length, GTP_MAX, GTPIE_PCO,
 		pdp->pco_neg.l, pdp->pco_neg.v);
     }
 
-    gtpie_tlv(packet.gtp0.p, &length, GTP_MAX, GTPIE_GSN_ADDR, 
+    gtpie_tlv(&packet, &length, GTP_MAX, GTPIE_GSN_ADDR, 
 	      pdp->gsnlc.l, pdp->gsnlc.v);
-    gtpie_tlv(packet.gtp0.p, &length, GTP_MAX, GTPIE_GSN_ADDR, 
+    gtpie_tlv(&packet, &length, GTP_MAX, GTPIE_GSN_ADDR, 
 	      pdp->gsnlu.l, pdp->gsnlu.v);
+
+    if (version == 1)
+      gtpie_tlv(&packet, &length, GTP_MAX, GTPIE_QOS_PROFILE,
+		pdp->qos_neg.l, pdp->qos_neg.v);
+
+    /* TODO: Charging gateway address */
   }
 
-  packet.gtp0.h.type = hton8(GTP_CREATE_PDP_RSP);
-  packet.gtp0.h.length = hton16(length);
-  packet.gtp0.h.flow = hton16(pdp->flrc);
-  packet.gtp0.h.seq = ((union gtp_packet*)pack)->gtp0.h.seq;
-  packet.gtp0.h.tid = ((union gtp_packet*)pack)->gtp0.h.tid;
-
-  return gtp_resp(0, gsn, &packet, GTP0_HEADER_SIZE+length, peer);
+  return gtp_resp(version, gsn, pdp, &packet, length, &pdp->sa_peer, 
+		  pdp->fd, pdp->seq, pdp->tid);
 }
 
 /* Handle Create PDP Context Request */
 int gtp_create_pdp_ind(struct gsn_t *gsn, int version,
-		       struct sockaddr_in *peer, void *pack, unsigned len) {
+			struct sockaddr_in *peer, int fd, 
+			void *pack, unsigned len) {
   struct pdp_t *pdp, *pdp_old; 
   struct pdp_t pdp_buf;
   union gtpie_member* ie[GTPIE_SIZE];
   uint8_t recovery;
-  uint64_t imsi;
-  uint8_t nsapi;
-  int auth = 0; /* Allow access if no callback is defined */
 
-  uint16_t seq = ntoh16(((union gtp_packet*)pack)->gtp0.h.seq);
+  uint16_t seq = get_seq(pack);
+  int hlen = get_hlen(pack);
 
-  if(!gtp_dublicate(gsn, 0, peer, seq)) {
-    return 0; /* We allready send of response once */
+  if(!gtp_dublicate(gsn, 0, peer, seq)) return 0;
+
+  pdp = &pdp_buf;
+  memset(pdp, 0, sizeof(struct pdp_t));
+
+  if (version == 0) {
+    pdp->imsi = ((union gtp_packet*)pack)->gtp0.h.tid & 0x0fffffffffffffff;
+    pdp->nsapi = (((union gtp_packet*)pack)->gtp0.h.tid & 0xf000000000000000) >> 60;
   }
 
+  pdp->seq = seq;
+  pdp->sa_peer = *peer;
+  pdp->fd = fd;
+  pdp->version = version;
+
   /* Decode information elements */
-  if (gtpie_decaps(ie, pack+GTP0_HEADER_SIZE, len-GTP0_HEADER_SIZE)) {
+  if (gtpie_decaps(ie, version, pack+hlen, len-hlen)) {
     gsn->invalid++;
     gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		"Invalid message format");
     if (0 == version)
       return EOF;
     else
-      return gtp_create_pdp_resp(gsn, version, peer, pack, len, pdp, 
-				 GTPCAUSE_INVALID_MESSAGE);
+      return gtp_create_pdp_resp(gsn, version, pdp, GTPCAUSE_INVALID_MESSAGE);
   }
 
-  pdp = &pdp_buf;
-  memset(pdp, 0, sizeof(struct pdp_t));
-
-  /* Extract IMSI and NSAPI from header */
-  imsi = ((union gtp_packet*)pack)->gtp0.h.tid & 0x0fffffffffffffff;
-  nsapi = (((union gtp_packet*)pack)->gtp0.h.tid & 0xf000000000000000) >> 60;
-
-  /* pdp_newpdp(&pdp, imsi, nsapi); TODO: Need to remove again */
-
-  if (gtpie_gettv0(ie, GTPIE_QOS_PROFILE0, 0,
-		   pdp->qos_req0, sizeof(pdp->qos_req0))) {
-    gsn->missing++;
-    gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
-		"Missing mandatory information field");
-    return gtp_create_pdp_resp(gsn, version, peer, pack, len, pdp, 
-			       GTPCAUSE_MAN_IE_MISSING);
+  if (version == 0) {
+    if (gtpie_gettv0(ie, GTPIE_QOS_PROFILE0, 0,
+		     pdp->qos_req0, sizeof(pdp->qos_req0))) {
+      gsn->missing++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
+		  "Missing mandatory information field");
+      return gtp_create_pdp_resp(gsn, version, pdp, GTPCAUSE_MAN_IE_MISSING);
+    }
   }
 
-  /* Extract recovery (optional) */
+
+  if (version == 1) {
+    /* IMSI (conditional) */
+    if (gtpie_gettv0(ie, GTPIE_IMSI, 0, &pdp->imsi, sizeof(pdp->imsi))) {
+      gsn->missing++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
+		  "Missing mandatory information field");
+      return gtp_create_pdp_resp(gsn, version, pdp, 
+				 GTPCAUSE_MAN_IE_MISSING);
+    }
+  }
+
+  /* Recovery (optional) */
   if (!gtpie_gettv1(ie, GTPIE_RECOVERY, 0, &recovery)) {
     /* TODO: Handle received recovery IE */
   }
 
+  /* Selection mode (conditional) */
   if (gtpie_gettv0(ie, GTPIE_SELECTION_MODE, 0,
 		   &pdp->selmode, sizeof(pdp->selmode))) {
     gsn->missing++;
     gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		"Missing mandatory information field");
-    return gtp_create_pdp_resp(gsn, version, peer, pack, len, pdp, 
+    return gtp_create_pdp_resp(gsn, version, pdp, 
 			       GTPCAUSE_MAN_IE_MISSING);
   }
 
-  if (gtpie_gettv2(ie, GTPIE_FL_DI, 0, &pdp->flru)) {
-    gsn->missing++;
-    gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
-		"Missing mandatory information field");
-    return gtp_create_pdp_resp(gsn, version, peer, pack, len, pdp, 
-			       GTPCAUSE_MAN_IE_MISSING);
+  if (version == 0) {
+    if (gtpie_gettv2(ie, GTPIE_FL_DI, 0, &pdp->flru)) {
+      gsn->missing++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
+		  "Missing mandatory information field");
+      return gtp_create_pdp_resp(gsn, version, pdp, 
+				 GTPCAUSE_MAN_IE_MISSING);
+    }
+    
+    if (gtpie_gettv2(ie, GTPIE_FL_C, 0, &pdp->flrc)) {
+      gsn->missing++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
+		  "Missing mandatory information field");
+      return gtp_create_pdp_resp(gsn, version, pdp, 
+				 GTPCAUSE_MAN_IE_MISSING);
+    }
   }
 
-  if (gtpie_gettv2(ie, GTPIE_FL_C, 0, &pdp->flrc)) {
-    gsn->missing++;
-    gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
-		"Missing mandatory information field");
-    return gtp_create_pdp_resp(gsn, version, peer, pack, len, pdp, 
-			       GTPCAUSE_MAN_IE_MISSING);
+
+  if (version == 1) {
+    /* TEID (mandatory) */
+    if (gtpie_gettv4(ie, GTPIE_TEI_DI, 0, &pdp->teid_gn)) {
+      gsn->missing++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
+		  "Missing mandatory information field");
+      return gtp_create_pdp_resp(gsn, version, pdp, 
+				 GTPCAUSE_MAN_IE_MISSING);
+    }
+
+    /* TEIC (conditional) */
+    if (gtpie_gettv4(ie, GTPIE_TEI_C, 0, &pdp->teic_gn)) {
+      gsn->missing++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
+		  "Missing mandatory information field");
+      return gtp_create_pdp_resp(gsn, version, pdp, 
+				 GTPCAUSE_MAN_IE_MISSING);
+    }
+
+    /* NSAPI (mandatory) */
+    if (gtpie_gettv1(ie, GTPIE_NSAPI, 0, &pdp->nsapi)) {
+      gsn->missing++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
+		  "Missing mandatory information field");
+      return gtp_create_pdp_resp(gsn, version, pdp, 
+				 GTPCAUSE_MAN_IE_MISSING);
+    }
+
+    /* Linked NSAPI (conditional) */
+    if (gtpie_gettv1(ie, GTPIE_NSAPI, 1, &pdp->linked_nsapi)) {
+      /* TODO: Handle linked NSAPI */
+      /* Currently the Secondary PDP Context Activation Procedure is not */
+      /* supported */
+    } else {
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
+		  "Found Linked NSAPI");
+      return gtp_create_pdp_resp(gsn, version, pdp, 
+				 GTPCAUSE_NOT_SUPPORTED);
+    }
   }
 
+  /* Charging Characteriatics (optional) */
+  /* Trace reference (optional) */
+  /* Trace type (optional) */
+  /* Charging Characteriatics (optional) */
+
+  /* End User Address (conditional) */
   if (gtpie_gettlv(ie, GTPIE_EUA, 0, &pdp->eua.l,
 		     &pdp->eua.v, sizeof(pdp->eua.v))) {
     gsn->missing++;
     gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		"Missing mandatory information field");
-    return gtp_create_pdp_resp(gsn, version, peer, pack, len, pdp, 
+    return gtp_create_pdp_resp(gsn, version, pdp, 
 			       GTPCAUSE_MAN_IE_MISSING);
   }
 
+  /* APN */
   if (gtpie_gettlv(ie, GTPIE_APN, 0, &pdp->apn_req.l,
 		     &pdp->apn_req.v, sizeof(pdp->apn_req.v))) {
     gsn->missing++;
     gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		"Missing mandatory information field");
-    return gtp_create_pdp_resp(gsn, version, peer, pack, len, pdp, 
+    return gtp_create_pdp_resp(gsn, version, pdp, 
 			       GTPCAUSE_MAN_IE_MISSING);
   }
 
   /* Extract protocol configuration options (optional) */
   if (!gtpie_gettlv(ie, GTPIE_PCO, 0, &pdp->pco_req.l,
 		    &pdp->pco_req.v, sizeof(pdp->pco_req.v))) {
-    /* TODO: Handle PCO IE */
   }
 
+  /* SGSN address for signalling (mandatory) */
   if (gtpie_gettlv(ie, GTPIE_GSN_ADDR, 0, &pdp->gsnrc.l,
 		     &pdp->gsnrc.v, sizeof(pdp->gsnrc.v))) {
     gsn->missing++;
     gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		"Missing mandatory information field");
-    return gtp_create_pdp_resp(gsn, version, peer, pack, len, pdp, 
+    return gtp_create_pdp_resp(gsn, version, pdp, 
 			       GTPCAUSE_MAN_IE_MISSING);
   }
 
+  /* SGSN address for user traffic (mandatory) */
   if (gtpie_gettlv(ie, GTPIE_GSN_ADDR, 1, &pdp->gsnru.l,
 		     &pdp->gsnru.v, sizeof(pdp->gsnru.v))) {
     gsn->missing++;
     gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		"Missing mandatory information field");
-    return gtp_create_pdp_resp(gsn, version, peer, pack, len, pdp, 
+    return gtp_create_pdp_resp(gsn, version, pdp, 
 			       GTPCAUSE_MAN_IE_MISSING);
   }
   
+  /* MSISDN (conditional) */
   if (gtpie_gettlv(ie, GTPIE_MSISDN, 0, &pdp->msisdn.l,
 		   &pdp->msisdn.v, sizeof(pdp->msisdn.v))) {
     gsn->missing++;
     gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		"Missing mandatory information field");
-    return gtp_create_pdp_resp(gsn, version, peer, pack, len, pdp, 
+    return gtp_create_pdp_resp(gsn, version, pdp, 
 			       GTPCAUSE_MAN_IE_MISSING);
   }
 
+  if (version == 1) {
+    /* QoS (mandatory) */
+    if (gtpie_gettlv(ie, GTPIE_QOS_PROFILE, 0, &pdp->qos_req.l,
+		     &pdp->qos_req.v, sizeof(pdp->qos_req.v))) {
+      gsn->missing++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
+		  "Missing mandatory information field");
+      return gtp_create_pdp_resp(gsn, version, pdp, 
+				 GTPCAUSE_MAN_IE_MISSING);
+    }
+
+    /* TFT (conditional) */
+    if (gtpie_gettlv(ie, GTPIE_TFT, 0, &pdp->tft.l,
+		     &pdp->tft.v, sizeof(pdp->tft.v))) {
+    }
+    
+    /* Trigger ID */
+    /* OMC identity */
+  }
+
+  /* Initialize our own IP addresses */
   in_addr2gsna(&pdp->gsnlc, &gsn->gsnc);
   in_addr2gsna(&pdp->gsnlu, &gsn->gsnu);
 
   if (GTP_DEBUG) printf("gtp_create_pdp_ind: Before pdp_tidget\n");
 
-  if (!pdp_tidget(&pdp_old, ((union gtp_packet*)pack)->gtp0.h.tid)) {
+  if (!pdp_getimsi(&pdp_old, pdp->imsi, pdp->nsapi)) {
     /* Found old pdp with same tid. Now the voodoo begins! */
+    /* 09.60 / 29.060 allows create on existing context to "steal" */
+    /* the context which was allready established */
     /* We check that the APN, selection mode and MSISDN is the same */
     if (GTP_DEBUG) printf("gtp_create_pdp_ind: Old context found\n"); 
-    if (   (pdp->apn_req.l == pdp_old->apn_req.l) 
+    if ((pdp->apn_req.l == pdp_old->apn_req.l) 
 	&& (!memcmp(pdp->apn_req.v, pdp_old->apn_req.v, pdp->apn_req.l)) 
 	&& (pdp->selmode == pdp_old->selmode)
 	&& (pdp->msisdn.l == pdp_old->msisdn.l) 
@@ -1147,18 +1324,20 @@
       pdp_old->flru = pdp->flru;
       pdp_old->flrc = pdp->flrc;
 
+      /* Copy remote tei */
+      pdp_old->teid_gn = pdp->teid_gn;
+      pdp_old->teic_gn = pdp->teic_gn;
+
       /* Copy peer GSN address */
       pdp_old->gsnrc.l = pdp->gsnrc.l;
       memcpy(&pdp_old->gsnrc.v, &pdp->gsnrc.v, pdp->gsnrc.l);
       pdp_old->gsnru.l = pdp->gsnru.l;
       memcpy(&pdp_old->gsnru.v, &pdp->gsnru.v, pdp->gsnru.l);
       
-      /* pdp_freepdp(pdp); not nessasary anymore since never allocated */
       pdp = pdp_old;
       
       /* Confirm to peer that things were "successful" */
-      return gtp_create_pdp_resp(gsn, version, peer, pack, len, pdp, 
-				 GTPCAUSE_ACC_REQ);
+      return gtp_create_pdp_resp(gsn, version, pdp, GTPCAUSE_ACC_REQ);
     }
     else { /* This is not the same PDP context. Delete the old one. */
 
@@ -1166,59 +1345,53 @@
       
       if (gsn->cb_delete_context) gsn->cb_delete_context(pdp_old);
       pdp_freepdp(pdp_old);
-
+      
       if (GTP_DEBUG) printf("gtp_create_pdp_ind: Deleted...\n");      
     }
   }
 
-  pdp_newpdp(&pdp, imsi, nsapi, pdp);
+  pdp_newpdp(&pdp, pdp->imsi, pdp->nsapi, pdp);
 
   /* Callback function to validata login */
-  if (gsn->cb_create_context !=0) 
-    auth = gsn->cb_create_context(pdp);
-
-  /* Now send off a reply to the peer */
-  if (!auth) {
-    return gtp_create_pdp_resp(gsn, version, peer, pack, len, pdp, 
-			       GTPCAUSE_ACC_REQ);
-  }
+  if (gsn->cb_create_context_ind !=0) 
+    return gsn->cb_create_context_ind(pdp);
   else {
-    gtp_create_pdp_resp(gsn, version, peer, pack, len, pdp, 
-			GTPCAUSE_USER_AUTH_FAIL);
-    pdp_freepdp(pdp);
-    return 0;
+    gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
+		"No create_context_ind callback defined");
+    return gtp_create_pdp_resp(gsn, version, pdp, GTPCAUSE_NOT_SUPPORTED);
   }
 }
 
 
 /* Handle Create PDP Context Response */
 int gtp_create_pdp_conf(struct gsn_t *gsn, int version,
-			struct sockaddr_in *peer, 
-			void *pack, unsigned len) {
+			 struct sockaddr_in *peer, 
+			 void *pack, unsigned len) {
   struct pdp_t *pdp; 
   union gtpie_member *ie[GTPIE_SIZE];
   uint8_t cause, recovery;
-  void *aid = NULL;
+  void *cbp = NULL;
   uint8_t type = 0;
+  int hlen = get_hlen(pack);
 
   /* Remove packet from queue */
-  if (gtp_conf(gsn, 0, peer, pack, len, &type, &aid)) return EOF;
+  if (gtp_conf(gsn, version, peer, pack, len, &type, &cbp)) return EOF;
   
   /* Find the context in question */
-  if (pdp_getgtp0(&pdp, ntoh16(((union gtp_packet*)pack)->gtp0.h.flow))) {
+  if (pdp_getgtp1(&pdp, get_tei(pack))) {
     gsn->err_unknownpdp++;
     gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		"Unknown PDP context");
-    if (gsn->cb_conf) gsn->cb_conf(type, EOF, NULL, aid);
+    if (gsn->cb_conf) gsn->cb_conf(type, EOF, NULL, cbp);
     return EOF;
   }
 
   /* Decode information elements */
-  if (gtpie_decaps(ie, pack+GTP0_HEADER_SIZE, len-GTP0_HEADER_SIZE)) {
+  if (gtpie_decaps(ie, version, pack+hlen, len-hlen)) {
     gsn->invalid++;
     gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		"Invalid message format");
-    if (gsn->cb_conf) gsn->cb_conf(type, EOF, pdp, aid);
+    if (gsn->cb_conf) gsn->cb_conf(type, EOF, pdp, cbp);
     return EOF;
   }
 
@@ -1227,7 +1400,7 @@
     gsn->missing++;
     gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		"Missing mandatory information field");
-    if (gsn->cb_conf) gsn->cb_conf(type, EOF, pdp, aid);
+    if (gsn->cb_conf) gsn->cb_conf(type, EOF, pdp, cbp);
     return EOF;
   }
 
@@ -1239,53 +1412,71 @@
   /* Extract protocol configuration options (optional) */
   if (!gtpie_gettlv(ie, GTPIE_PCO, 0, &pdp->pco_req.l,
 		    &pdp->pco_req.v, sizeof(pdp->pco_req.v))) {
-    /* TODO: Handle PCO IE */
   }
 
   /* Check all conditional information elements */
   if (GTPCAUSE_ACC_REQ == cause) {
 
-    if (gtpie_gettv0(ie, GTPIE_QOS_PROFILE0, 0,   /* TODO: HACK only gtp0 */
-		     &pdp->qos_neg0, sizeof(pdp->qos_neg0))) {
-      gsn->missing++;
-      gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
-		  "Missing conditional information field");
-      if (gsn->cb_conf) gsn->cb_conf(type, EOF, pdp, aid);
-      return EOF;
+    if (version == 0) {
+      if (gtpie_gettv0(ie, GTPIE_QOS_PROFILE0, 0,
+		       &pdp->qos_neg0, sizeof(pdp->qos_neg0))) {
+	gsn->missing++;
+	gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
+		    "Missing conditional information field");
+	if (gsn->cb_conf) gsn->cb_conf(type, EOF, pdp, cbp);
+	return EOF;
+      }
     }
-    /* pdp->qos_neg.l = 3;  * TODO: HACK only gtp0 */
     
     if (gtpie_gettv1(ie, GTPIE_REORDER, 0, &pdp->reorder)) {
       gsn->missing++;
       gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		  "Missing conditional information field");
-      if (gsn->cb_conf) gsn->cb_conf(type, EOF, pdp, aid);
+      if (gsn->cb_conf) gsn->cb_conf(type, EOF, pdp, cbp);
       return EOF;
     }
 
-    if (gtpie_gettv2(ie, GTPIE_FL_DI, 0, &pdp->flru)) {
-      gsn->missing++;
-      gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
-		  "Missing conditional information field");
-      if (gsn->cb_conf) gsn->cb_conf(type, EOF, pdp, aid);
-      return EOF;
-    }
+    if (version == 0) {
+      if (gtpie_gettv2(ie, GTPIE_FL_DI, 0, &pdp->flru)) {
+	gsn->missing++;
+	gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
+		    "Missing conditional information field");
+	if (gsn->cb_conf) gsn->cb_conf(type, EOF, pdp, cbp);
+	return EOF;
+      }
     
-    if (gtpie_gettv2(ie, GTPIE_FL_C, 0, &pdp->flrc)) {
-      gsn->missing++;
-      gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
-		  "Missing conditional information field");
-      if (gsn->cb_conf) gsn->cb_conf(type, EOF, pdp, aid);
-      return EOF;
+      if (gtpie_gettv2(ie, GTPIE_FL_C, 0, &pdp->flrc)) {
+	gsn->missing++;
+	gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
+		    "Missing conditional information field");
+	if (gsn->cb_conf) gsn->cb_conf(type, EOF, pdp, cbp);
+	return EOF;
+      }
+    }
+
+    if (version == 1) {
+      if (gtpie_gettv4(ie, GTPIE_TEI_DI, 0, &pdp->teid_gn)) {
+	gsn->missing++;
+	gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
+		    "Missing conditional information field");
+	if (gsn->cb_conf) gsn->cb_conf(type, EOF, pdp, cbp);
+	return EOF;
+      }
+    
+      if (gtpie_gettv4(ie, GTPIE_TEI_C, 0, &pdp->teic_gn)) {
+	gsn->missing++;
+	gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
+		    "Missing conditional information field");
+	if (gsn->cb_conf) gsn->cb_conf(type, EOF, pdp, cbp);
+	return EOF;
+      }
     }
     
     if (gtpie_gettv4(ie, GTPIE_CHARGING_ID, 0, &pdp->cid)) {
       gsn->missing++;
       gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		  "Missing conditional information field");
-      if (gsn->cb_conf) gsn->cb_conf(type, EOF, pdp, aid);
-      return gtp_create_pdp_resp(gsn, version, peer, pack, len, pdp, 
-				 GTPCAUSE_MAN_IE_MISSING);
+      if (gsn->cb_conf) gsn->cb_conf(type, EOF, pdp, cbp);
     }
     
     if (gtpie_gettlv(ie, GTPIE_EUA, 0, &pdp->eua.l,
@@ -1293,7 +1484,7 @@
       gsn->missing++;
       gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		  "Missing conditional information field");
-      if (gsn->cb_conf) gsn->cb_conf(type, EOF, pdp, aid);
+      if (gsn->cb_conf) gsn->cb_conf(type, EOF, pdp, cbp);
       return EOF;
     }
     
@@ -1302,7 +1493,7 @@
       gsn->missing++;
       gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		  "Missing conditional information field");
-      if (gsn->cb_conf) gsn->cb_conf(type, EOF, pdp, aid);
+      if (gsn->cb_conf) gsn->cb_conf(type, EOF, pdp, cbp);
       return EOF;
     }
     
@@ -1311,178 +1502,375 @@
       gsn->missing++;
       gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		  "Missing conditional information field");
-      if (gsn->cb_conf) gsn->cb_conf(type, EOF, pdp, aid);
+      if (gsn->cb_conf) gsn->cb_conf(type, EOF, pdp, cbp);
       return EOF;
     }
-  }
 
-  if (gsn->cb_conf) gsn->cb_conf(type, cause, pdp, aid);
+    if (version == 1) {
+      if (gtpie_gettlv(ie, GTPIE_QOS_PROFILE, 0, &pdp->qos_neg.l,
+		       &pdp->qos_neg.v, sizeof(pdp->qos_neg.v))) {
+	gsn->missing++;
+	gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
+		    "Missing conditional information field");
+	if (gsn->cb_conf) gsn->cb_conf(type, EOF, pdp, cbp);
+	return EOF;
+      }
+    }
+    
+  }
+  
+  if (gsn->cb_conf) gsn->cb_conf(type, cause, pdp, cbp);
 
   return 0;
 }
 
-/* Send Update PDP Context Request */
-extern int gtp_update_pdp_req(struct gsn_t *gsn, int version, void *aid,
-			      struct in_addr* inetaddr, struct pdp_t *pdp) {
-  union gtp_packet packet;
-  int length = 0;
 
-  get_default_gtp(0, &packet);
+/* API: Send Update PDP Context Request */
+int gtp_update_context(struct gsn_t *gsn, struct pdp_t *pdp, void *cbp,
+		       struct in_addr* inetaddr) {
+  union gtp_packet packet;
+  int length = get_default_gtp(pdp->version, GTP_UPDATE_PDP_REQ, &packet);
   
-  gtpie_tv0(packet.gtp0.p, &length, GTP_MAX, GTPIE_QOS_PROFILE0, 
-	    sizeof(pdp->qos_req0), pdp->qos_req0);
-  gtpie_tv1(packet.gtp0.p, &length, GTP_MAX, GTPIE_RECOVERY, 
+  if (pdp->version == 0)
+    gtpie_tv0(&packet, &length, GTP_MAX, GTPIE_QOS_PROFILE0, 
+	      sizeof(pdp->qos_req0), pdp->qos_req0);
+
+  if (pdp->version == 1)
+    gtpie_tv0(&packet, &length, GTP_MAX, GTPIE_IMSI, 
+	      sizeof(pdp->imsi), (uint8_t*) &pdp->imsi);
+
+  gtpie_tv1(&packet, &length, GTP_MAX, GTPIE_RECOVERY, 
 	    gsn->restart_counter);
-  gtpie_tv2(packet.gtp0.p, &length, GTP_MAX, GTPIE_FL_DI, 
-	    pdp->fllu);
-  gtpie_tv2(packet.gtp0.p, &length, GTP_MAX, GTPIE_FL_C,
-	    pdp->fllc);
-  gtpie_tlv(packet.gtp0.p, &length, GTP_MAX, GTPIE_GSN_ADDR, 
-	    pdp->gsnlc.l, pdp->gsnlc.v);
-  gtpie_tlv(packet.gtp0.p, &length, GTP_MAX, GTPIE_GSN_ADDR, 
-	    pdp->gsnlu.l, pdp->gsnlu.v);
-  
-  packet.gtp0.h.type = hton8(GTP_UPDATE_PDP_REQ);
-  packet.gtp0.h.length = hton16(length);
-  packet.gtp0.h.flow = 0;
-  packet.gtp0.h.tid = (pdp->imsi & 0x0fffffffffffffff) + ((uint64_t)pdp->nsapi << 60);
 
-  return gtp_req(gsn, 0, &packet, GTP0_HEADER_SIZE+length, inetaddr, aid);
-}
-
-/* Send Update PDP Context Response */
-int gtp_update_pdp_resp(struct gsn_t *gsn, int version,
-			struct sockaddr_in *peer, 
-			void *pack, unsigned len, 
-			struct pdp_t *pdp, uint8_t cause)
-{
-  union gtp_packet packet;
-  int length = 0;
-
-  get_default_gtp(0, &packet);
-
-  gtpie_tv1(packet.gtp0.p, &length, GTP_MAX, GTPIE_CAUSE, cause);
-
-  if (cause == GTPCAUSE_ACC_REQ) {
-    gtpie_tv0(packet.gtp0.p, &length, GTP_MAX, GTPIE_QOS_PROFILE0, 
-	      sizeof(pdp->qos_sub0), pdp->qos_sub0);
-    gtpie_tv1(packet.gtp0.p, &length, GTP_MAX, GTPIE_RECOVERY, 
-	      gsn->restart_counter);
-    gtpie_tv2(packet.gtp0.p, &length, GTP_MAX, GTPIE_FL_DI, 
+  if (pdp->version == 0) {
+    gtpie_tv2(&packet, &length, GTP_MAX, GTPIE_FL_DI, 
 	      pdp->fllu);
-    gtpie_tv2(packet.gtp0.p, &length, GTP_MAX, GTPIE_FL_C,
+    gtpie_tv2(&packet, &length, GTP_MAX, GTPIE_FL_C,
 	      pdp->fllc);
-    gtpie_tv4(packet.gtp0.p, &length, GTP_MAX, GTPIE_CHARGING_ID,
-	      0x12345678);
-    gtpie_tlv(packet.gtp0.p, &length, GTP_MAX, GTPIE_GSN_ADDR, 
-	      pdp->gsnlc.l, pdp->gsnlc.v);
-    gtpie_tlv(packet.gtp0.p, &length, GTP_MAX, GTPIE_GSN_ADDR, 
-	      pdp->gsnlu.l, pdp->gsnlu.v);
   }
 
-  packet.gtp0.h.type = hton8(GTP_UPDATE_PDP_RSP);
-  packet.gtp0.h.length = hton16(length);
-  packet.gtp0.h.flow = hton16(pdp->flrc);
-  packet.gtp0.h.seq = ((union gtp_packet*)pack)->gtp0.h.seq;
-  packet.gtp0.h.tid = (pdp->imsi & 0x0fffffffffffffff) + ((uint64_t)pdp->nsapi << 60);
+  if (pdp->version == 1) {
+    gtpie_tv4(&packet, &length, GTP_MAX, GTPIE_TEI_DI,
+	      pdp->teid_own);
+    gtpie_tv4(&packet, &length, GTP_MAX, GTPIE_TEI_C,
+	      pdp->teic_own);
+  }
 
-  return gtp_resp(0, gsn, &packet, GTP0_HEADER_SIZE+length, peer);
+  gtpie_tv1(&packet, &length, GTP_MAX, GTPIE_NSAPI, 
+	    pdp->nsapi);
+
+  /* TODO 
+  gtpie_tv2(&packet, &length, GTP_MAX, GTPIE_TRACE_REF,
+	    pdp->traceref);
+  gtpie_tv2(&packet, &length, GTP_MAX, GTPIE_TRACE_TYPE,
+	    pdp->tracetype); */
+
+  /* TODO if ggsn update message
+  gtpie_tlv(&packet, &length, GTP_MAX, GTPIE_EUA, 
+	    pdp->eua.l, pdp->eua.v);
+  */
+
+  gtpie_tlv(&packet, &length, GTP_MAX, GTPIE_GSN_ADDR, 
+	    pdp->gsnlc.l, pdp->gsnlc.v);
+  gtpie_tlv(&packet, &length, GTP_MAX, GTPIE_GSN_ADDR, 
+	    pdp->gsnlu.l, pdp->gsnlu.v);
+
+  if (pdp->version == 1) 
+    gtpie_tlv(&packet, &length, GTP_MAX, GTPIE_QOS_PROFILE,
+	      pdp->qos_req.l, pdp->qos_req.v);
+
+
+  if ((pdp->version == 1) && pdp->tft.l)
+    gtpie_tlv(&packet, &length, GTP_MAX, GTPIE_TFT,
+	      pdp->tft.l, pdp->tft.v);
+  
+  if ((pdp->version == 1) && pdp->triggerid.l)
+    gtpie_tlv(&packet, &length, GTP_MAX, GTPIE_TRIGGER_ID,
+	      pdp->triggerid.l, pdp->triggerid.v);
+  
+  if ((pdp->version == 1) && pdp->omcid.l)
+    gtpie_tlv(&packet, &length, GTP_MAX, GTPIE_OMC_ID,
+	      pdp->omcid.l, pdp->omcid.v);
+  
+  gtp_req(gsn, pdp->version, NULL, &packet, length, inetaddr, cbp);
+
+  return 0;
 }
 
+
+/* Send Update PDP Context Response */
+int gtp_update_pdp_resp(struct gsn_t *gsn, int version, 
+			struct sockaddr_in *peer, int fd, 
+			void *pack, unsigned len,
+			struct pdp_t *pdp, uint8_t cause) {
+  
+  union gtp_packet packet;
+  int length = get_default_gtp(version, GTP_CREATE_PDP_RSP, &packet);
+  
+  gtpie_tv1(&packet, &length, GTP_MAX, GTPIE_CAUSE, cause);
+  
+  if (cause == GTPCAUSE_ACC_REQ) {
+    
+    if (version == 0) 
+      gtpie_tv0(&packet, &length, GTP_MAX, GTPIE_QOS_PROFILE0, 
+		sizeof(pdp->qos_neg0), pdp->qos_neg0);
+
+    gtpie_tv1(&packet, &length, GTP_MAX, GTPIE_RECOVERY, 
+	      gsn->restart_counter);
+
+    if (version == 0) {
+      gtpie_tv2(&packet, &length, GTP_MAX, GTPIE_FL_DI, 
+		pdp->fllu);
+      gtpie_tv2(&packet, &length, GTP_MAX, GTPIE_FL_C,
+		pdp->fllc);
+    }
+
+    if (version == 1) {
+      gtpie_tv4(&packet, &length, GTP_MAX, GTPIE_TEI_DI, 
+		pdp->teid_own);
+      gtpie_tv4(&packet, &length, GTP_MAX, GTPIE_TEI_C,
+		pdp->teic_own);
+    }
+
+    gtpie_tv4(&packet, &length, GTP_MAX, GTPIE_CHARGING_ID,
+	      0x12345678); /* TODO */
+
+    /* If ggsn 
+    gtpie_tlv(&packet, &length, GTP_MAX, GTPIE_EUA, 
+	      pdp->eua.l, pdp->eua.v); */
+
+    gtpie_tlv(&packet, &length, GTP_MAX, GTPIE_GSN_ADDR, 
+	      pdp->gsnlc.l, pdp->gsnlc.v);
+    gtpie_tlv(&packet, &length, GTP_MAX, GTPIE_GSN_ADDR, 
+	      pdp->gsnlu.l, pdp->gsnlu.v);
+
+    if (version == 1)
+      gtpie_tlv(&packet, &length, GTP_MAX, GTPIE_QOS_PROFILE,
+		pdp->qos_neg.l, pdp->qos_neg.v);
+
+    /* TODO: Charging gateway address */
+  }
+
+  return gtp_resp(version, gsn, pdp, &packet, length, &pdp->sa_peer, 
+		  pdp->fd, pdp->seq, pdp->tid);
+}
+
+
 /* Handle Update PDP Context Request */
 int gtp_update_pdp_ind(struct gsn_t *gsn, int version,
-		       struct sockaddr_in *peer, void *pack, unsigned len) {
-  struct pdp_t *pdp, *pdp2; 
-  struct pdp_t pdp_buf;
+		       struct sockaddr_in *peer, int fd, 
+		       void *pack, unsigned len) {
+  struct pdp_t *pdp;
+  struct pdp_t pdp_backup;
   union gtpie_member* ie[GTPIE_SIZE];
   uint8_t recovery;
 
-  uint16_t seq = ntoh16(((union gtp_packet*)pack)->gtp0.h.seq);
+  uint16_t seq = get_seq(pack);
+  int hlen = get_hlen(pack);
 
+  uint64_t imsi;
+  uint8_t nsapi;
+  
   /* Is this a dublicate ? */
-  if(!gtp_dublicate(gsn, 0, peer, seq)) {
+  if(!gtp_dublicate(gsn, version, peer, seq)) {
     return 0; /* We allready send of response once */
   }
 
-  /* Find the pdp context in question */
-  if (pdp_getgtp0(&pdp, ntoh16(((union gtp_packet*)pack)->gtp0.h.flow))) {
-    gsn->err_unknownpdp++;
-    gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
-		"Unknown PDP context");
-    return gtp_update_pdp_resp(gsn, version, peer, pack, len, NULL,
-			       GTPCAUSE_NON_EXIST);
-  }
   
   /* Decode information elements */
-  if (gtpie_decaps(ie, pack+GTP0_HEADER_SIZE, len-GTP0_HEADER_SIZE)) {
+  if (gtpie_decaps(ie, version, pack+hlen, len-hlen)) {
     gsn->invalid++;
     gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		"Invalid message format");
     if (0 == version)
       return EOF;
     else
-      return gtp_update_pdp_resp(gsn, version, peer, pack, len, pdp, 
-				 GTPCAUSE_INVALID_MESSAGE);
+      return gtp_update_pdp_resp(gsn, version, peer, fd, pack, len,
+				 NULL, GTPCAUSE_INVALID_MESSAGE);
   }
 
-  pdp2 = &pdp_buf;
-  memcpy(pdp2, pdp, sizeof (struct pdp_t)); /* Generate local copy */
+  /* Finding PDP: */
+  /* For GTP0 we use the tunnel identifier to provide imsi and nsapi. */
+  /* For GTP1 we must use imsi and nsapi if imsi is present. Otherwise */
+  /* we have to use the tunnel endpoint identifier */
+  if (version == 0) {
+    imsi = ((union gtp_packet*)pack)->gtp0.h.tid & 0x0fffffffffffffff;
+    nsapi = (((union gtp_packet*)pack)->gtp0.h.tid & 0xf000000000000000) >> 60;
 
-  if (gtpie_gettv0(ie, GTPIE_QOS_PROFILE0, 0,   /* TODO: HACK only gtp0 */
-		     &pdp2->qos_req0, sizeof(pdp2->qos_req0))) {
-    gsn->missing++;
-    gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
-		"Missing mandatory information field");
-    return gtp_update_pdp_resp(gsn, version, peer, pack, len, pdp2,
-			       GTPCAUSE_MAN_IE_MISSING);
+    /* Find the context in question */
+    if (pdp_getimsi(&pdp, imsi, nsapi)) {
+      gsn->err_unknownpdp++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
+		  "Unknown PDP context");
+      return gtp_update_pdp_resp(gsn, version, peer, fd, pack, len, 
+				 NULL, GTPCAUSE_NON_EXIST);
+    }
   }
-  /* pdp2->qos_req.l = 3;  * TODO: HACK only gtp0 */
+  else if (version == 1) {
+    /* NSAPI (mandatory) */
+    if (gtpie_gettv1(ie, GTPIE_NSAPI, 0, &nsapi)) {
+      gsn->missing++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
+		  "Missing mandatory information field");
+      return gtp_update_pdp_resp(gsn, version, peer, fd, pack, len,
+				 NULL, GTPCAUSE_MAN_IE_MISSING);
+    }
 
-  /* Extract recovery (optional) */
+    /* IMSI (conditional) */
+    if (gtpie_gettv0(ie, GTPIE_IMSI, 0, &imsi, sizeof(imsi))) {
+      /* Find the context in question */
+      if (pdp_getgtp1(&pdp, get_tei(pack))) {
+	gsn->err_unknownpdp++;
+	gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
+		    "Unknown PDP context");
+	return gtp_update_pdp_resp(gsn, version, peer, fd, pack, len,
+				   NULL, GTPCAUSE_NON_EXIST);
+      }
+    }
+    else {
+      /* Find the context in question */
+      if (pdp_getimsi(&pdp, imsi, nsapi)) {
+	gsn->err_unknownpdp++;
+	gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
+		    "Unknown PDP context");
+	return gtp_update_pdp_resp(gsn, version, peer, fd, pack, len,
+				   NULL, GTPCAUSE_NON_EXIST);
+      }
+    }
+  }
+  else {
+    gtp_err(LOG_ERR, __FILE__, __LINE__, "Unknown version");
+    return EOF;
+  }
+
+  /* Make a backup copy in case anything is wrong */
+  memcpy(&pdp_backup, pdp, sizeof(pdp_backup));
+
+  if (version == 0) {
+    if (gtpie_gettv0(ie, GTPIE_QOS_PROFILE0, 0,
+		     pdp->qos_req0, sizeof(pdp->qos_req0))) {
+      gsn->missing++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
+		  "Missing mandatory information field");
+      memcpy(pdp, &pdp_backup, sizeof(pdp_backup));
+      return gtp_update_pdp_resp(gsn, version, peer, fd, pack, len, 
+				 pdp, GTPCAUSE_MAN_IE_MISSING);
+    }
+  }
+
+  /* Recovery (optional) */
   if (!gtpie_gettv1(ie, GTPIE_RECOVERY, 0, &recovery)) {
     /* TODO: Handle received recovery IE */
   }
 
-  if (gtpie_gettv2(ie, GTPIE_FL_DI, 0, &pdp2->flru)) {
+  if (version == 0) {
+    if (gtpie_gettv2(ie, GTPIE_FL_DI, 0, &pdp->flru)) {
+      gsn->missing++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
+		  "Missing mandatory information field");
+      memcpy(pdp, &pdp_backup, sizeof(pdp_backup));
+      return gtp_update_pdp_resp(gsn, version, peer, fd, pack, len, pdp, 
+				 GTPCAUSE_MAN_IE_MISSING);
+    }
+    
+    if (gtpie_gettv2(ie, GTPIE_FL_C, 0, &pdp->flrc)) {
+      gsn->missing++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
+		  "Missing mandatory information field");
+      memcpy(pdp, &pdp_backup, sizeof(pdp_backup));
+      return gtp_update_pdp_resp(gsn, version, peer, fd, pack, len, pdp, 
+				 GTPCAUSE_MAN_IE_MISSING);
+    }
+  }
+
+
+  if (version == 1) {
+    /* TEID (mandatory) */
+    if (gtpie_gettv4(ie, GTPIE_TEI_DI, 0, &pdp->teid_gn)) {
+      gsn->missing++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
+		  "Missing mandatory information field");
+      memcpy(pdp, &pdp_backup, sizeof(pdp_backup));
+      return gtp_update_pdp_resp(gsn, version, peer, fd, pack, len, pdp, 
+				 GTPCAUSE_MAN_IE_MISSING);
+    }
+
+    /* TEIC (conditional) */
+    /* If TEIC is not included it means that we have allready received it */
+    if (gtpie_gettv4(ie, GTPIE_TEI_C, 0, &pdp->teic_gn)) {
+    }
+
+    /* NSAPI (mandatory) */
+    if (gtpie_gettv1(ie, GTPIE_NSAPI, 0, &pdp->nsapi)) {
+      gsn->missing++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
+		  "Missing mandatory information field");
+      memcpy(pdp, &pdp_backup, sizeof(pdp_backup));
+      return gtp_update_pdp_resp(gsn, version, peer, fd, pack, len, pdp, 
+				 GTPCAUSE_MAN_IE_MISSING);
+    }
+  }
+  
+  /* Trace reference (optional) */
+  /* Trace type (optional) */
+
+  /* End User Address (conditional) TODO: GGSN Initiated
+  if (gtpie_gettlv(ie, GTPIE_EUA, 0, &pdp->eua.l,
+		     &pdp->eua.v, sizeof(pdp->eua.v))) {
     gsn->missing++;
     gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		"Missing mandatory information field");
-    return gtp_update_pdp_resp(gsn, version, peer, pack, len, pdp2, 
+    memcpy(pdp, &pdp_backup, sizeof(pdp_backup));
+    return gtp_update_pdp_resp(gsn, version, pdp, 
 			       GTPCAUSE_MAN_IE_MISSING);
-  }
+  } */
 
-  if (gtpie_gettv2(ie, GTPIE_FL_C, 0, &pdp2->flrc)) {
+
+  /* SGSN address for signalling (mandatory) */
+  /* It is weird that this is mandatory when TEIC is conditional */
+  if (gtpie_gettlv(ie, GTPIE_GSN_ADDR, 0, &pdp->gsnrc.l,
+		     &pdp->gsnrc.v, sizeof(pdp->gsnrc.v))) {
     gsn->missing++;
     gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		"Missing mandatory information field");
-    return gtp_update_pdp_resp(gsn, version, peer, pack, len, pdp2, 
+    memcpy(pdp, &pdp_backup, sizeof(pdp_backup));
+    return gtp_update_pdp_resp(gsn, version, peer, fd, pack, len, pdp, 
 			       GTPCAUSE_MAN_IE_MISSING);
   }
 
-  if (gtpie_gettlv(ie, GTPIE_GSN_ADDR, 0, &pdp2->gsnrc.l,
-		     &pdp2->gsnrc.v, sizeof(pdp2->gsnrc.v))) {
+  /* SGSN address for user traffic (mandatory) */
+  if (gtpie_gettlv(ie, GTPIE_GSN_ADDR, 1, &pdp->gsnru.l,
+		     &pdp->gsnru.v, sizeof(pdp->gsnru.v))) {
     gsn->missing++;
     gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		"Missing mandatory information field");
-    return gtp_update_pdp_resp(gsn, version, peer, pack, len, pdp2, 
+    memcpy(pdp, &pdp_backup, sizeof(pdp_backup));
+    return gtp_update_pdp_resp(gsn, version, peer, fd, pack, len, pdp, 
 			       GTPCAUSE_MAN_IE_MISSING);
   }
+  
+  if (version == 1) {
+    /* QoS (mandatory) */
+    if (gtpie_gettlv(ie, GTPIE_QOS_PROFILE, 0, &pdp->qos_req.l,
+		     &pdp->qos_req.v, sizeof(pdp->qos_req.v))) {
+      gsn->missing++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
+		  "Missing mandatory information field");
+      memcpy(pdp, &pdp_backup, sizeof(pdp_backup));
+      return gtp_update_pdp_resp(gsn, version, peer, fd, pack, len, pdp, 
+				 GTPCAUSE_MAN_IE_MISSING);
+    }
 
-  if (gtpie_gettlv(ie, GTPIE_GSN_ADDR, 1, &pdp2->gsnru.l,
-		     &pdp2->gsnru.v, sizeof(pdp2->gsnru.v))) {
-    gsn->missing++;
-    gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
-		"Missing mandatory information field");
-    return gtp_update_pdp_resp(gsn, version, peer, pack, len, pdp2, 
-			       GTPCAUSE_MAN_IE_MISSING);
+    /* TFT (conditional) */
+    if (gtpie_gettlv(ie, GTPIE_TFT, 0, &pdp->tft.l,
+		     &pdp->tft.v, sizeof(pdp->tft.v))) {
+    }
+    
+    /* OMC identity */
   }
 
-  /* OK! It seames as if we received a valid message */
-
-  memcpy(pdp, pdp2, sizeof (struct pdp_t)); /* Update original pdp */
-
   /* Confirm to peer that things were "successful" */
-  return gtp_update_pdp_resp(gsn, version, peer, pack, len, pdp, 
+  return gtp_update_pdp_resp(gsn, version, peer, fd, pack, len, pdp, 
 			     GTPCAUSE_ACC_REQ);
 }
 
@@ -1494,27 +1882,27 @@
   struct pdp_t *pdp; 
   union gtpie_member *ie[GTPIE_SIZE];
   uint8_t cause, recovery;
-  void *aid = NULL;
+  void *cbp = NULL;
   uint8_t type = 0;
   
   /* Remove packet from queue */
-  if (gtp_conf(gsn, 0, peer, pack, len, &type, &aid)) return EOF;
+  if (gtp_conf(gsn, 0, peer, pack, len, &type, &cbp)) return EOF;
 
   /* Find the context in question */
   if (pdp_getgtp0(&pdp, ntoh16(((union gtp_packet*)pack)->gtp0.h.flow))) {
     gsn->err_unknownpdp++;
     gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		"Unknown PDP context");
-    if (gsn->cb_conf) gsn->cb_conf(type, cause, NULL, aid);
+    if (gsn->cb_conf) gsn->cb_conf(type, cause, NULL, cbp);
     return EOF;
   }
 
   /* Decode information elements */
-  if (gtpie_decaps(ie, pack+GTP0_HEADER_SIZE, len-GTP0_HEADER_SIZE)) {
+  if (gtpie_decaps(ie, 0, pack+GTP0_HEADER_SIZE, len-GTP0_HEADER_SIZE)) {
     gsn->invalid++;
     gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		"Invalid message format");
-    if (gsn->cb_conf) gsn->cb_conf(type, EOF, pdp, aid);
+    if (gsn->cb_conf) gsn->cb_conf(type, EOF, pdp, cbp);
     if (gsn->cb_delete_context) gsn->cb_delete_context(pdp);
     pdp_freepdp(pdp);
     return EOF;
@@ -1525,7 +1913,7 @@
     gsn->missing++;
     gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		"Missing mandatory information field");
-    if (gsn->cb_conf) gsn->cb_conf(type, EOF, pdp, aid);
+    if (gsn->cb_conf) gsn->cb_conf(type, EOF, pdp, cbp);
     if (gsn->cb_delete_context) gsn->cb_delete_context(pdp);
     pdp_freepdp(pdp);
     return EOF;
@@ -1538,7 +1926,7 @@
 
   /* Check all conditional information elements */
   if (GTPCAUSE_ACC_REQ != cause) {
-    if (gsn->cb_conf) gsn->cb_conf(type, cause, pdp, aid);
+    if (gsn->cb_conf) gsn->cb_conf(type, cause, pdp, cbp);
     if (gsn->cb_delete_context) gsn->cb_delete_context(pdp);
     pdp_freepdp(pdp);
     return 0;
@@ -1556,7 +1944,7 @@
       gsn->missing++;
       gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		  "Missing conditional information field");
-      if (gsn->cb_conf) gsn->cb_conf(type, EOF, pdp, aid);
+      if (gsn->cb_conf) gsn->cb_conf(type, EOF, pdp, cbp);
       if (gsn->cb_delete_context) gsn->cb_delete_context(pdp);
       pdp_freepdp(pdp);
       return EOF;
@@ -1576,55 +1964,51 @@
     gtpie_gettlv(ie, GTPIE_GSN_ADDR, 1, &pdp->gsnru.l,
 		 &pdp->gsnru.v, sizeof(pdp->gsnru.v));
     
-    if (gsn->cb_conf) gsn->cb_conf(type, cause, pdp, aid);
+    if (gsn->cb_conf) gsn->cb_conf(type, cause, pdp, cbp);
     return 0; /* Succes */
   }
 }
 
-/* Send Delete PDP Context Request */
-extern int gtp_delete_pdp_req(struct gsn_t *gsn, int version, void *aid,
-			      struct pdp_t *pdp) {
-  union gtp_packet packet;
-  int length = 0;
-  struct in_addr addr;
 
+/* API: Send Delete PDP Context Request */
+int gtp_delete_context_req(struct gsn_t *gsn, struct pdp_t *pdp, void *cbp) {
+  union gtp_packet packet;
+  int length = get_default_gtp(pdp->version, GTP_CREATE_PDP_REQ, &packet);
+  struct in_addr addr;
+  
   if (gsna2in_addr(&addr, &pdp->gsnrc)) {
     gsn->err_address++;
     gtp_err(LOG_ERR, __FILE__, __LINE__, "GSN address conversion failed");
     return EOF;
   }
+  
+  if (pdp->version == 1) {
+    gtpie_tv1(&packet, &length, GTP_MAX, GTPIE_NSAPI, 
+	      pdp->nsapi);
 
-  get_default_gtp(0, &packet);
+    gtpie_tv1(&packet, &length, GTP_MAX, GTPIE_TEARDOWN,
+	      0xff);
+  }
 
-  packet.gtp0.h.type = hton8(GTP_DELETE_PDP_REQ);
-  packet.gtp0.h.length = hton16(length);
-  packet.gtp0.h.flow = hton16(pdp->flrc);
-  packet.gtp0.h.tid = (pdp->imsi & 0x0fffffffffffffff) + ((uint64_t)pdp->nsapi << 60);
-
-  return gtp_req(gsn, 0, &packet, GTP0_HEADER_SIZE+length, &addr, aid);
+  get_default_gtp(pdp->version, GTP_DELETE_PDP_REQ, &packet);
+  
+  return gtp_req(gsn, pdp->version, pdp, &packet, length, &addr, cbp);
 }
 
+
 /* Send Delete PDP Context Response */
 int gtp_delete_pdp_resp(struct gsn_t *gsn, int version,
-			struct sockaddr_in *peer, 
+			struct sockaddr_in *peer, int fd,
 			void *pack, unsigned len, 
 			struct pdp_t *pdp, uint8_t cause)
 {
   union gtp_packet packet;
-  int length = 0;
-  uint16_t flow = 0;
-  
-  if (pdp) flow = hton16(pdp->flrc);
-  
-  get_default_gtp(0, &packet);
+  int length = get_default_gtp(version, GTP_DELETE_PDP_RSP, &packet);
 
-  gtpie_tv1(packet.gtp0.p, &length, GTP_MAX, GTPIE_CAUSE, cause);
+  gtpie_tv1(&packet, &length, GTP_MAX, GTPIE_CAUSE, cause);
 
-  packet.gtp0.h.type = hton8(GTP_DELETE_PDP_RSP);
-  packet.gtp0.h.length = hton16(length);
-  packet.gtp0.h.flow = flow;
-  packet.gtp0.h.seq = ((union gtp_packet*)pack)->gtp0.h.seq;
-  packet.gtp0.h.tid = ((union gtp_packet*)pack)->gtp0.h.tid;
+  gtp_resp(version, gsn, pdp, &packet, length, peer, fd,
+	   get_seq(pack),get_tid(pack));
 
   if (pdp) {
     /* Callback function to allow application to clean up */
@@ -1632,47 +2016,74 @@
     pdp_freepdp(pdp); /* Clean up PDP context */
   }
   
-  return gtp_resp(0, gsn, &packet, GTP0_HEADER_SIZE+length, peer);
+  return 0;
 }
 
 /* Handle Delete PDP Context Request */
 int gtp_delete_pdp_ind(struct gsn_t *gsn, int version,
-		       struct sockaddr_in *peer, void *pack, unsigned len) {
-  struct pdp_t *pdp; 
+		       struct sockaddr_in *peer, int fd,
+		       void *pack, unsigned len) {
+  struct pdp_t *pdp;
   union gtpie_member* ie[GTPIE_SIZE];
-  uint16_t seq = ntoh16(((union gtp_packet*)pack)->gtp0.h.seq);
+  
+  uint16_t seq = get_seq(pack);
+  int hlen = get_hlen(pack);
 
+  uint8_t nsapi;
+  uint8_t teardown;
+  
   /* Is this a dublicate ? */
-  if(!gtp_dublicate(gsn, 0, peer, seq)) {
-    return 0;
+  if(!gtp_dublicate(gsn, version, peer, seq)) {
+    return 0; /* We allready send off response once */
   }
 
-  /* Find the pdp context in question */
-  if (pdp_getgtp0(&pdp, ntoh16(((union gtp_packet*)pack)->gtp0.h.flow))) {
+  /* Find the context in question */
+  if (pdp_getgtp1(&pdp, get_tei(pack))) {
     gsn->err_unknownpdp++;
     gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		"Unknown PDP context");
-    if (0 == version)
-      return gtp_delete_pdp_resp(gsn, version, peer, pack, len, NULL,
-				 GTPCAUSE_ACC_REQ);
-    else
-      return gtp_delete_pdp_resp(gsn, version, peer, pack, len, NULL,
-				 GTPCAUSE_NON_EXIST);
+    return gtp_delete_pdp_resp(gsn, version, peer, fd, pack, len,
+			       NULL, GTPCAUSE_NON_EXIST);
   }
   
   /* Decode information elements */
-  if (gtpie_decaps(ie, pack+GTP0_HEADER_SIZE, len-GTP0_HEADER_SIZE)) {
+  if (gtpie_decaps(ie, version, pack+hlen, len-hlen)) {
     gsn->invalid++;
     gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		"Invalid message format");
     if (0 == version)
       return EOF;
     else
-      return gtp_delete_pdp_resp(gsn, version, peer, pack, len, pdp, 
-				 GTPCAUSE_INVALID_MESSAGE);
+      return gtp_delete_pdp_resp(gsn, version, peer, fd, pack, len,
+				 NULL, GTPCAUSE_INVALID_MESSAGE);
   }
 
-  return gtp_delete_pdp_resp(gsn, version, peer, pack, len, pdp,
+  if (version == 1) {
+    /* NSAPI (mandatory) */
+    if (gtpie_gettv1(ie, GTPIE_NSAPI, 0, &nsapi)) {
+      gsn->missing++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
+		  "Missing mandatory information field");
+      return gtp_delete_pdp_resp(gsn, version, peer, fd, pack, len,
+				 NULL, GTPCAUSE_MAN_IE_MISSING);
+    }
+
+    /* TODO: When multiple contexts with the same IP address exists
+       we need to tear down each one individually or as a group depending
+       on the value of teardown */
+    
+    /* Teardown (conditional) */
+    if (gtpie_gettv1(ie, GTPIE_TEARDOWN, 0, &teardown)) {
+      return 0; /* 29.060 7.3.5 Ignore message */
+      /* gsn->missing++;
+	 gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
+      "Missing mandatory information field");
+		  return gtp_delete_pdp_resp(gsn, version, peer, fd, pack, len,
+      NULL, GTPCAUSE_MAN_IE_MISSING); */
+    }
+  }
+  
+  return gtp_delete_pdp_resp(gsn, version, peer, fd, pack, len, pdp,
 			     GTPCAUSE_ACC_REQ);
 }
 
@@ -1684,33 +2095,37 @@
   struct pdp_t *pdp; 
   union gtpie_member *ie[GTPIE_SIZE];
   uint8_t cause;
-  void *aid = NULL;
+  void *cbp = NULL;
   uint8_t type = 0;
-
+  int hlen = get_hlen(pack);
+  
   /* Remove packet from queue */
-  if (gtp_conf(gsn, 0, peer, pack, len, &type, &aid)) return EOF;
+  if (gtp_conf(gsn, version, peer, pack, len, &type, &cbp)) return EOF;
   
   /* Find the context in question */
-  if (pdp_getgtp0(&pdp, ntoh16(((union gtp_packet*)pack)->gtp0.h.flow))) {
+  if (pdp_getgtp1(&pdp, get_tei(pack))) {
     gsn->err_unknownpdp++;
     gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		"Unknown PDP context");
+    if (gsn->cb_conf) gsn->cb_conf(type, EOF, NULL, cbp);
     return EOF;
   }
 
   /* Decode information elements */
-  if (gtpie_decaps(ie, pack+GTP0_HEADER_SIZE, len-GTP0_HEADER_SIZE)) {
+  if (gtpie_decaps(ie, version, pack+hlen, len-hlen)) {
     gsn->invalid++;
     gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		"Invalid message format");
+    if (gsn->cb_conf) gsn->cb_conf(type, EOF, pdp, cbp);
     return EOF;
   }
 
-  /* Extract cause value */
+  /* Extract cause value (mandatory) */
   if (gtpie_gettv1(ie, GTPIE_CAUSE, 0, &cause)) {
     gsn->missing++;
     gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		"Missing mandatory information field");
+    if (gsn->cb_conf) gsn->cb_conf(type, EOF, pdp, cbp);
     return EOF;
   }
 
@@ -1719,12 +2134,12 @@
     gsn->err_cause++;
     gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		"Unexpected cause value received: %d", cause);
-    return EOF;
   }
 
-  /* Callback function to allow application to clean up */
-  if (gsn->cb_conf) gsn->cb_conf(type, cause, pdp, aid);
+  /* Callback function to notify application */
+  if (gsn->cb_conf) gsn->cb_conf(type, cause, pdp, cbp);
 
+  /* Callback function to allow application to clean up */
   if (gsn->cb_delete_context) gsn->cb_delete_context(pdp);
   pdp_freepdp(pdp);  
   
@@ -1733,21 +2148,14 @@
 
 /* Send Error Indication (response to a GPDU message */
 int gtp_error_ind_resp(struct gsn_t *gsn, int version,
-		       struct sockaddr_in *peer, 
+		       struct sockaddr_in *peer, int fd,
 		       void *pack, unsigned len)
 {
   union gtp_packet packet;
-  int length = 0;
+  int length = get_default_gtp(version, GTP_ERROR, &packet);
   
-  get_default_gtp(0, &packet);
-  
-  packet.gtp0.h.type = hton8(GTP_ERROR);
-  packet.gtp0.h.length = hton16(length);
-  packet.gtp0.h.flow = 0;
-  packet.gtp0.h.seq = ((union gtp_packet*)pack)->gtp0.h.seq;
-  packet.gtp0.h.tid = ((union gtp_packet*)pack)->gtp0.h.tid;
-  
-  return gtp_resp(0, gsn, &packet, GTP0_HEADER_SIZE+length, peer);
+  return gtp_resp(version, gsn, NULL, &packet, length, peer, fd,
+		  get_seq(pack), get_tid(pack));
 }
 
 /* Handle Error Indication */
@@ -1774,78 +2182,93 @@
 }
 
 int gtp_gpdu_ind(struct gsn_t *gsn, int version,
-		 struct sockaddr_in *peer,
-		 void *pack,
-		 unsigned len) {
+		  struct sockaddr_in *peer, int fd,
+		  void *pack, unsigned len) {
+
+  int hlen = GTP1_HEADER_SIZE_SHORT;
 
   /* Need to include code to verify packet src and dest addresses */
   struct pdp_t *pdp; 
-  
-  if (pdp_getgtp0(&pdp, ntoh16(((union gtp_packet*)pack)->gtp0.h.flow))) {
-    gsn->err_unknownpdp++;
-    gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
-		"Unknown PDP context");
-    return gtp_error_ind_resp(gsn, version, peer, pack, len);
- 
-  }
 
+  if (version == 0) {
+    if (pdp_getgtp0(&pdp, ntoh16(((union gtp_packet*)pack)->gtp0.h.flow))) {
+      gsn->err_unknownpdp++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
+		  "Unknown PDP context");
+      return gtp_error_ind_resp(gsn, version, peer, fd, pack, len);
+    }
+    hlen = GTP0_HEADER_SIZE;
+  }
+  else if (version == 1) {
+    if (pdp_getgtp1(&pdp, ntoh32(((union gtp_packet*)pack)->gtp1l.h.tei))) {
+      gsn->err_unknownpdp++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
+		  "Unknown PDP context");
+      return gtp_error_ind_resp(gsn, version, peer, fd, pack, len);
+    }
+
+    /* Is this a long or a short header ? */
+    if (((union gtp_packet*)pack)->gtp1l.h.flags & 0x07)
+      hlen = GTP1_HEADER_SIZE_LONG;
+    else
+      hlen = GTP1_HEADER_SIZE_SHORT;
+  }
+  else {
+    gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
+		"Unknown version");
+  }
+  
   /* If the GPDU was not from the peer GSN tell him to delete context */
   if (memcmp(&peer->sin_addr, pdp->gsnru.v, pdp->gsnru.l)) { /* TODO Range? */
     gsn->err_unknownpdp++;
     gtp_errpack(LOG_ERR, __FILE__, __LINE__, peer, pack, len,
 		"Unknown PDP context");
-    return gtp_error_ind_resp(gsn, version, peer, pack, len);
+    return gtp_error_ind_resp(gsn, version, peer, fd, pack, len);
   }
-  
+
   /* Callback function */
-  if (gsn->cb_gpdu !=0)
-    return gsn->cb_gpdu(pdp, pack+20, len-20); /* TODO ???? */
+  if (gsn->cb_data_ind !=0)
+    return gsn->cb_data_ind(pdp, pack+hlen, len-hlen);
 
   return 0;
 }
 
 
+
 /* Receives GTP packet and sends off for further processing 
  * Function will check the validity of the header. If the header
  * is not valid the packet is either dropped or a version not 
  * supported is returned to the peer. 
  * TODO: Need to decide on return values! */
-int gtp_decaps(struct gsn_t *gsn)
+int gtp_decaps0(struct gsn_t *gsn)
 {
   unsigned char buffer[PACKET_MAX + 64 /*TODO: ip header */ ];
-  int status, ip_len = 0;
   struct sockaddr_in peer;
   int peerlen;
+  int status;
   struct gtp0_header *pheader;
   int version = 0; /* GTP version should be determined from header!*/
+  int fd = gsn->fd0;
 
   /* TODO: Need strategy of userspace buffering and blocking */
   /* Currently read is non-blocking and send is blocking. */
   /* This means that the program have to wait for busy send calls...*/
 
   while (1) { /* Loop until no more to read */
-    if (fcntl(gsn->fd, F_SETFL, O_NONBLOCK)) {
+    if (fcntl(gsn->fd0, F_SETFL, O_NONBLOCK)) {
       gtp_err(LOG_ERR, __FILE__, __LINE__, "fnctl()");
       return -1;
     }
     peerlen = sizeof(peer);
     if ((status = 
-	 recvfrom(gsn->fd, buffer, sizeof(buffer), 0,
+	 recvfrom(gsn->fd0, buffer, sizeof(buffer), 0,
 		  (struct sockaddr *) &peer, &peerlen)) < 0 ) {
-      if (errno == EAGAIN) return -1;
+      if (errno == EAGAIN) return 0;
       gsn->err_readfrom++;
-      gtp_err(LOG_ERR, __FILE__, __LINE__, "recvfrom(fd=%d, buffer=%lx, len=%d) failed: status = %d error = %s", gsn->fd, (unsigned long) buffer, sizeof(buffer), status, status ? strerror(errno) : "No error");
+      gtp_err(LOG_ERR, __FILE__, __LINE__, "recvfrom(fd0=%d, buffer=%lx, len=%d) failed: status = %d error = %s", gsn->fd0, (unsigned long) buffer, sizeof(buffer), status, status ? strerror(errno) : "No error");
       return -1;
     }
   
-    /* Strip off IP header, if present: TODO Is this nessesary? */
-    if ((buffer[0] & 0xF0) == 0x40) {
-      ip_len = (buffer[0] & 0xF) * 4;
-      gtp_errpack(LOG_ERR, __FILE__, __LINE__, &peer, buffer, status,
-		  "IP header found in return from read");
-      continue;
-    }
-    
     /* Need at least 1 byte in order to check version */
     if (status < (1)) {
       gsn->empty++;
@@ -1854,30 +2277,184 @@
       continue;
     }
     
-    /* TODO: Remove these ERROR MESSAGES 
-       gtp_err(LOG_ERR, __FILE__, __LINE__, "Discarding packet - too small");
-       gtp_errpack(LOG_ERR, __FILE__, __LINE__, &peer, buffer, status,
-       "Discarding packet - too small"); */
+    pheader = (struct gtp0_header *) (buffer);
     
-    pheader = (struct gtp0_header *) (buffer + ip_len);
-    
-    /* Version should be gtp0 (or earlier in theory) */
+    /* Version should be gtp0 (or earlier) */
+    /* 09.60 is somewhat unclear on this issue. On gsn->fd0 we expect only */
+    /* GTP 0 messages. If other version message is received we reply that we */
+    /* only support version 0, implying that this is the only version */
+    /* supported on this port */
     if (((pheader->flags & 0xe0) > 0x00)) {
       gsn->unsup++;
       gtp_errpack(LOG_ERR, __FILE__, __LINE__, &peer, buffer, status,
 		  "Unsupported GTP version");
-      gtp_unsup_resp(gsn, &peer, buffer, status); /* 29.60: 11.1.1 */
+      gtp_unsup_req(gsn, 0, &peer, gsn->fd0, buffer, status); /* 29.60: 11.1.1 */
       continue;
     }
     
     /* Check length of gtp0 packet */
-    if (((pheader->flags & 0xe0) == 0x00) && (status < GTP0_HEADER_SIZE)) {
+    if (status < GTP0_HEADER_SIZE) {
       gsn->tooshort++;
       gtp_errpack(LOG_ERR, __FILE__, __LINE__, &peer, buffer, status,
 		  "GTP0 packet too short");
       continue;  /* Silently discard 29.60: 11.1.2 */
     }
 
+    /* Check packet length field versus length of packet */
+    if (status != (ntoh16(pheader->length) + GTP0_HEADER_SIZE)) {
+      gsn->tooshort++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, &peer, buffer, status,
+		  "GTP packet length field does not match actual length");
+      continue;  /* Silently discard */
+    }
+    
+    if ((gsn->mode == GTP_MODE_GGSN) && 
+	((pheader->type == GTP_CREATE_PDP_RSP) ||
+	 (pheader->type == GTP_UPDATE_PDP_RSP) ||
+	 (pheader->type == GTP_DELETE_PDP_RSP))) {
+      gsn->unexpect++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, &peer, buffer, status,
+		  "Unexpected GTP Signalling Message");
+      continue;  /* Silently discard 29.60: 11.1.4 */
+    }
+
+    if ((gsn->mode == GTP_MODE_SGSN) && 
+	((pheader->type == GTP_CREATE_PDP_REQ) ||
+	 (pheader->type == GTP_UPDATE_PDP_REQ) ||
+	 (pheader->type == GTP_DELETE_PDP_REQ))) {
+      gsn->unexpect++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, &peer, buffer, status,
+		  "Unexpected GTP Signalling Message");
+      continue;  /* Silently discard 29.60: 11.1.4 */
+    }
+
+    switch (pheader->type) {
+    case GTP_ECHO_REQ:
+      gtp_echo_ind(gsn, version, &peer, fd, buffer, status);
+      break;
+    case GTP_ECHO_RSP:
+      gtp_echo_conf(gsn, version, &peer, buffer, status);
+      break;
+    case GTP_NOT_SUPPORTED:
+      gtp_unsup_ind(gsn, &peer, buffer, status);
+      break;
+    case GTP_CREATE_PDP_REQ:
+      gtp_create_pdp_ind(gsn, version, &peer, fd, buffer, status);
+      break;
+    case GTP_CREATE_PDP_RSP:
+      gtp_create_pdp_conf(gsn, version, &peer, buffer, status);
+      break;
+    case GTP_UPDATE_PDP_REQ:
+      gtp_update_pdp_ind(gsn, version, &peer, fd, buffer, status);
+      break;
+    case GTP_UPDATE_PDP_RSP:
+      gtp_update_pdp_conf(gsn, version, &peer, buffer, status);
+      break;
+    case GTP_DELETE_PDP_REQ:
+      gtp_delete_pdp_ind(gsn, version, &peer, fd, buffer, status);
+      break;
+    case GTP_DELETE_PDP_RSP:
+      gtp_delete_pdp_conf(gsn, version, &peer, buffer, status);
+      break;
+    case GTP_ERROR:
+      gtp_error_ind_conf(gsn, version, &peer, buffer, status);
+      break;
+    case GTP_GPDU:
+      gtp_gpdu_ind(gsn, version, &peer, fd, buffer, status);
+      break;
+    default:
+      gsn->unknown++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, &peer, buffer, status,
+		  "Unknown GTP message type received");
+      break;
+    }
+  }
+}
+
+
+int gtp_decaps1c(struct gsn_t *gsn)
+{
+  unsigned char buffer[PACKET_MAX + 64 /*TODO: ip header */ ];
+  struct sockaddr_in peer;
+  int peerlen;
+  int status;
+  struct gtp1_header_short *pheader;
+  int version = 1; /* GTP version should be determined from header!*/
+  int fd = gsn->fd1c;
+
+  /* TODO: Need strategy of userspace buffering and blocking */
+  /* Currently read is non-blocking and send is blocking. */
+  /* This means that the program have to wait for busy send calls...*/
+
+  while (1) { /* Loop until no more to read */
+    if (fcntl(gsn->fd1c, F_SETFL, O_NONBLOCK)) {
+      gtp_err(LOG_ERR, __FILE__, __LINE__, "fnctl()");
+      return -1;
+    }
+    peerlen = sizeof(peer);
+    if ((status = 
+	 recvfrom(gsn->fd1c, buffer, sizeof(buffer), 0,
+		  (struct sockaddr *) &peer, &peerlen)) < 0 ) {
+      if (errno == EAGAIN) return 0;
+      gsn->err_readfrom++;
+      gtp_err(LOG_ERR, __FILE__, __LINE__, "recvfrom(fd1c=%d, buffer=%lx, len=%d) failed: status = %d error = %s", gsn->fd1c, (unsigned long) buffer, sizeof(buffer), status, status ? strerror(errno) : "No error");
+      return -1;
+    }
+  
+    /* Need at least 1 byte in order to check version */
+    if (status < (1)) {
+      gsn->empty++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, &peer, buffer, status,
+		  "Discarding packet - too small");
+      continue;
+    }
+    
+    pheader = (struct gtp1_header_short *) (buffer);
+    
+    /* Version must be no larger than GTP 1 */
+    if (((pheader->flags & 0xe0) > 0x20)) {
+      gsn->unsup++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, &peer, buffer, status,
+		  "Unsupported GTP version");
+      gtp_unsup_req(gsn, 1, &peer, gsn->fd1c, buffer, status);/*29.60: 11.1.1*/
+      continue;
+    }
+
+    /* Version must be at least GTP 1 */
+    /* 29.060 is somewhat unclear on this issue. On gsn->fd1c we expect only */
+    /* GTP 1 messages. If GTP 0 message is received we silently discard */
+    /* the message */
+    if (((pheader->flags & 0xe0) < 0x20)) {
+      gsn->unsup++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, &peer, buffer, status,
+		  "Unsupported GTP version");
+      continue;
+    }
+
+    /* Check packet flag field */
+    if (((pheader->flags & 0xf7) != 0x32)) {
+      gsn->unsup++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, &peer, buffer, status,
+		  "Unsupported packet flag");
+      continue;
+    }
+
+    /* Check length of packet */
+    if (status < GTP1_HEADER_SIZE_LONG) {
+      gsn->tooshort++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, &peer, buffer, status,
+		  "GTP packet too short");
+      continue;  /* Silently discard 29.60: 11.1.2 */
+    }
+
+    /* Check packet length field versus length of packet */
+    if (status != (ntoh16(pheader->length) + GTP1_HEADER_SIZE_SHORT)) {
+      gsn->tooshort++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, &peer, buffer, status,
+		  "GTP packet length field does not match actual length");
+      continue;  /* Silently discard */
+    }
+
     if ((gsn->mode == GTP_MODE_GGSN) && 
 	((pheader->type == GTP_CREATE_PDP_RSP) ||
 	 (pheader->type == GTP_UPDATE_PDP_RSP) ||
@@ -1898,48 +2475,36 @@
       continue;  /* Silently discard 29.60: 11.1.4 */
     }
 
-
-    
     switch (pheader->type) {
     case GTP_ECHO_REQ:
-      gtp_echo_ind(gsn, &peer, buffer+ip_len, status - ip_len);
+      gtp_echo_ind(gsn, version, &peer, fd, buffer, status);
       break;
     case GTP_ECHO_RSP:
-      gtp_echo_conf(gsn, &peer, buffer+ip_len, status - ip_len);
+      gtp_echo_conf(gsn, version, &peer, buffer, status);
       break;
     case GTP_NOT_SUPPORTED:
-      gtp_unsup_conf(gsn, &peer, buffer+ip_len, status - ip_len);
+      gtp_unsup_ind(gsn, &peer, buffer, status);
       break;
     case GTP_CREATE_PDP_REQ:
-      gtp_create_pdp_ind(gsn, version, &peer, buffer+ip_len, 
-			 status - ip_len);
+      gtp_create_pdp_ind(gsn, version, &peer, fd, buffer, status);
       break;
     case GTP_CREATE_PDP_RSP:
-      gtp_create_pdp_conf(gsn, version, &peer, buffer+ip_len, 
-			  status - ip_len);
+      gtp_create_pdp_conf(gsn, version, &peer, buffer, status);
       break;
     case GTP_UPDATE_PDP_REQ:
-      gtp_update_pdp_ind(gsn, version, &peer, buffer+ip_len, 
-			 status - ip_len);
+      gtp_update_pdp_ind(gsn, version, &peer, fd, buffer, status);
       break;
     case GTP_UPDATE_PDP_RSP:
-      gtp_update_pdp_conf(gsn, version, &peer, buffer+ip_len, 
-			  status - ip_len);
+      gtp_update_pdp_conf(gsn, version, &peer, buffer, status);
       break;
     case GTP_DELETE_PDP_REQ:
-      gtp_delete_pdp_ind(gsn, version, &peer, buffer+ip_len, 
-			 status - ip_len);
+      gtp_delete_pdp_ind(gsn, version, &peer, fd, buffer, status);
       break;
     case GTP_DELETE_PDP_RSP:
-      gtp_delete_pdp_conf(gsn, version, &peer, buffer+ip_len, 
-			  status - ip_len);
+      gtp_delete_pdp_conf(gsn, version, &peer, buffer, status);
       break;
     case GTP_ERROR:
-      gtp_error_ind_conf(gsn, version, &peer, buffer+ip_len, 
-			 status - ip_len);
-      break;
-    case GTP_GPDU:
-      gtp_gpdu_ind(gsn, version, &peer, buffer+ip_len, status - ip_len);
+      gtp_error_ind_conf(gsn, version, &peer, buffer, status);
       break;
     default:
       gsn->unknown++;
@@ -1950,46 +2515,178 @@
   }
 }
 
-int gtp_gpdu(struct gsn_t *gsn, struct pdp_t* pdp, 
+int gtp_decaps1u(struct gsn_t *gsn)
+{
+  unsigned char buffer[PACKET_MAX + 64 /*TODO: ip header */ ];
+  struct sockaddr_in peer;
+  int peerlen;
+  int status;
+  struct gtp1_header_short *pheader;
+  int version = 1; /* GTP version should be determined from header!*/
+  int fd = gsn->fd1u;
+
+  /* TODO: Need strategy of userspace buffering and blocking */
+  /* Currently read is non-blocking and send is blocking. */
+  /* This means that the program have to wait for busy send calls...*/
+
+  while (1) { /* Loop until no more to read */
+    if (fcntl(gsn->fd1u, F_SETFL, O_NONBLOCK)) {
+      gtp_err(LOG_ERR, __FILE__, __LINE__, "fnctl()");
+      return -1;
+    }
+    peerlen = sizeof(peer);
+    if ((status = 
+	 recvfrom(gsn->fd1u, buffer, sizeof(buffer), 0,
+		  (struct sockaddr *) &peer, &peerlen)) < 0 ) {
+      if (errno == EAGAIN) return 0;
+      gsn->err_readfrom++;
+      gtp_err(LOG_ERR, __FILE__, __LINE__, "recvfrom(fd1u=%d, buffer=%lx, len=%d) failed: status = %d error = %s", gsn->fd1u, (unsigned long) buffer, sizeof(buffer), status, status ? strerror(errno) : "No error");
+      return -1;
+    }
+  
+    /* Need at least 1 byte in order to check version */
+    if (status < (1)) {
+      gsn->empty++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, &peer, buffer, status,
+		  "Discarding packet - too small");
+      continue;
+    }
+    
+    pheader = (struct gtp1_header_short *) (buffer);
+    
+    /* Version must be no larger than GTP 1 */
+    if (((pheader->flags & 0xe0) > 0x20)) {
+      gsn->unsup++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, &peer, buffer, status,
+		  "Unsupported GTP version");
+      gtp_unsup_req(gsn, 1, &peer, gsn->fd1c, buffer, status);/*29.60: 11.1.1*/
+      continue;
+    }
+
+    /* Version must be at least GTP 1 */
+    /* 29.060 is somewhat unclear on this issue. On gsn->fd1c we expect only */
+    /* GTP 1 messages. If GTP 0 message is received we silently discard */
+    /* the message */
+    if (((pheader->flags & 0xe0) < 0x20)) {
+      gsn->unsup++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, &peer, buffer, status,
+		  "Unsupported GTP version");
+      continue;
+    }
+
+    /* Check packet flag field (allow both with and without sequence number)*/
+    if (((pheader->flags & 0xf5) != 0x30)) {
+      gsn->unsup++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, &peer, buffer, status,
+		  "Unsupported packet flag");
+      continue;
+    }
+
+    /* Check length of packet */
+    if (status < GTP1_HEADER_SIZE_SHORT) {
+      gsn->tooshort++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, &peer, buffer, status,
+		  "GTP packet too short");
+      continue;  /* Silently discard 29.60: 11.1.2 */
+    }
+
+    /* Check packet length field versus length of packet */
+    if (status != (ntoh16(pheader->length) + GTP1_HEADER_SIZE_SHORT)) {
+      gsn->tooshort++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, &peer, buffer, status,
+		  "GTP packet length field does not match actual length");
+      continue;  /* Silently discard */
+    }
+    
+    switch (pheader->type) {
+    case GTP_ECHO_REQ:
+      gtp_echo_ind(gsn, version, &peer, fd, buffer, status);
+      break;
+    case GTP_ECHO_RSP:
+      gtp_echo_conf(gsn, version, &peer, buffer, status);
+      break;
+    case GTP_ERROR:
+      gtp_error_ind_conf(gsn, version, &peer, buffer, status);
+      break;
+      /* Supported header extensions */
+    case GTP_GPDU:
+      gtp_gpdu_ind(gsn, version, &peer, fd, buffer, status);
+      break;
+    default:
+      gsn->unknown++;
+      gtp_errpack(LOG_ERR, __FILE__, __LINE__, &peer, buffer, status,
+		  "Unknown GTP message type received");
+      break;
+    }
+  }
+}
+
+int gtp_data_req(struct gsn_t *gsn, struct pdp_t* pdp, 
 	     void *pack, unsigned len)
 {
   union gtp_packet packet;
   struct sockaddr_in addr;
-
-  /*printf("gtp_encaps start\n");
-    print_packet(pack, len);*/
+  int fd;
+  int length;
 
   memset(&addr, 0, sizeof(addr));
   addr.sin_family = AF_INET;
-
   memcpy(&addr.sin_addr, pdp->gsnru.v,pdp->gsnru.l); /* TODO range check */
-  addr.sin_port = htons(GTP0_PORT);
 
-  get_default_gtp(0, &packet);
-  packet.gtp0.h.type = hton8(GTP_GPDU);
-  packet.gtp0.h.length = hton16(len);
-  packet.gtp0.h.seq = hton16(pdp->gtpsntx++);
-  packet.gtp0.h.flow = hton16(pdp->flru);
-  packet.gtp0.h.tid = (pdp->imsi & 0x0fffffffffffffff) + ((uint64_t)pdp->nsapi << 60);
+  if (pdp->version == 0) {
+    
+    length = GTP0_HEADER_SIZE+len;
+    addr.sin_port = htons(GTP0_PORT);
+    fd = gsn->fd0;
+    
+    get_default_gtp(0, GTP_GPDU, &packet);
+    packet.gtp0.h.length = hton16(len);
+    packet.gtp0.h.seq = hton16(pdp->gtpsntx++);
+    packet.gtp0.h.flow = hton16(pdp->flru);
+    packet.gtp0.h.tid = (pdp->imsi & 0x0fffffffffffffff) + ((uint64_t)pdp->nsapi << 60);
 
-  if (len > sizeof (union gtp_packet) - sizeof(struct gtp0_header)) {
-    gsn->err_memcpy++;
-    gtp_err(LOG_ERR, __FILE__, __LINE__, 
-	    "Memcpy failed");
-    return EOF;
+    if (len > sizeof (union gtp_packet) - sizeof(struct gtp0_header)) {
+      gsn->err_memcpy++;
+      gtp_err(LOG_ERR, __FILE__, __LINE__, 
+	      "Memcpy failed");
+      return EOF;
     }
+    memcpy(packet.gtp0.p, pack, len); /* TODO Should be avoided! */
+  }
+  else if (pdp->version == 1) {
+    
+    length = GTP1_HEADER_SIZE_LONG+len;
+    addr.sin_port = htons(GTP1U_PORT);
+    fd = gsn->fd1u;
 
-  if (fcntl(gsn->fd, F_SETFL, 0)) {
+    get_default_gtp(1, GTP_GPDU, &packet);
+    packet.gtp1l.h.length = hton16(len-GTP1_HEADER_SIZE_SHORT+
+				   GTP1_HEADER_SIZE_LONG);
+    packet.gtp1l.h.seq = hton16(pdp->gtpsntx++);
+
+    if (len > sizeof (union gtp_packet) - sizeof(struct gtp1_header_long)) {
+      gsn->err_memcpy++;
+      gtp_err(LOG_ERR, __FILE__, __LINE__, 
+	      "Memcpy failed");
+      return EOF;
+    }
+    memcpy(packet.gtp1l.p, pack, len); /* TODO Should be avoided! */
+  }
+  else {
+    gtp_err(LOG_ERR, __FILE__, __LINE__, 
+	    "Unknown version");
+    return EOF;
+  }
+
+  if (fcntl(fd, F_SETFL, 0)) {
     gtp_err(LOG_ERR, __FILE__, __LINE__, "fnctl()");
     return -1;
   }
 
-  memcpy(packet.gtp0.p, pack, len); /* TODO Should be avoided! */
-  
-  if (sendto(gsn->fd, &packet, GTP0_HEADER_SIZE+len, 0,
+  if (sendto(fd, &packet, length, 0,
 	     (struct sockaddr *) &addr, sizeof(addr)) < 0) {
     gsn->err_sendto++;
-    gtp_err(LOG_ERR, __FILE__, __LINE__, "Sendto(fd=%d, msg=%lx, len=%d) failed: Error = %s", gsn->fd, (unsigned long) &packet, GTP0_HEADER_SIZE+len, strerror(errno));
+    gtp_err(LOG_ERR, __FILE__, __LINE__, "Sendto(fd=%d, msg=%lx, len=%d) failed: Error = %s", fd, (unsigned long) &packet, GTP0_HEADER_SIZE+len, strerror(errno));
     return EOF;
   }
   return 0;