mediation extension adapted to the naming convention of the current version of the...
authorTobias Brunner <tobias@strongswan.org>
Wed, 26 Mar 2008 18:40:19 +0000 (18:40 -0000)
committerTobias Brunner <tobias@strongswan.org>
Wed, 26 Mar 2008 18:40:19 +0000 (18:40 -0000)
49 files changed:
configure.in
src/charon/Makefile.am
src/charon/config/peer_cfg.c
src/charon/config/peer_cfg.h
src/charon/daemon.c
src/charon/daemon.h
src/charon/encoding/message.c
src/charon/encoding/payloads/endpoint_notify.c
src/charon/encoding/payloads/endpoint_notify.h
src/charon/encoding/payloads/ike_header.c
src/charon/encoding/payloads/ike_header.h
src/charon/encoding/payloads/notify_payload.c
src/charon/encoding/payloads/notify_payload.h
src/charon/encoding/payloads/payload.c
src/charon/encoding/payloads/payload.h
src/charon/plugins/stroke/stroke_config.c
src/charon/plugins/stroke/stroke_socket.c
src/charon/processing/jobs/mediation_job.c
src/charon/processing/jobs/mediation_job.h
src/charon/processing/jobs/process_message_job.c
src/charon/sa/connect_manager.c
src/charon/sa/connect_manager.h
src/charon/sa/ike_sa.c
src/charon/sa/ike_sa.h
src/charon/sa/task_manager.c
src/charon/sa/tasks/ike_auth.c
src/charon/sa/tasks/ike_me.c [new file with mode: 0644]
src/charon/sa/tasks/ike_me.h [new file with mode: 0644]
src/charon/sa/tasks/ike_natd.c
src/charon/sa/tasks/ike_p2p.c [deleted file]
src/charon/sa/tasks/ike_p2p.h [deleted file]
src/charon/sa/tasks/task.c
src/charon/sa/tasks/task.h
src/starter/args.c
src/starter/confread.h
src/starter/keywords.h
src/starter/keywords.txt
src/starter/starterstroke.c
src/stroke/stroke.c
src/stroke/stroke_msg.h
testing/tests/p2pnat/behind-same-nat/evaltest.dat
testing/tests/p2pnat/behind-same-nat/hosts/alice/etc/init.d/iptables
testing/tests/p2pnat/behind-same-nat/hosts/alice/etc/ipsec.conf
testing/tests/p2pnat/behind-same-nat/hosts/venus/etc/init.d/iptables
testing/tests/p2pnat/behind-same-nat/hosts/venus/etc/ipsec.conf
testing/tests/p2pnat/medsrv-psk/evaltest.dat
testing/tests/p2pnat/medsrv-psk/hosts/alice/etc/init.d/iptables
testing/tests/p2pnat/medsrv-psk/hosts/alice/etc/ipsec.conf
testing/tests/p2pnat/medsrv-psk/hosts/bob/etc/ipsec.conf

index c13d19b..a7a11d2 100644 (file)
@@ -453,13 +453,13 @@ AM_CONDITIONAL(USE_MANAGER, test x$manager = xtrue)
 
 AC_ARG_ENABLE(
     [p2p],
-    AS_HELP_STRING([--enable-p2p],[enable peer-to-peer NAT traversal (default is NO).]),
+    AS_HELP_STRING([--enable-p2p],[enable mediation extensions for IKEv2 (default is NO).]),
     [if test x$enableval = xyes; then
-        p2p=true
-        AC_DEFINE(P2P)
+        me=true
+        AC_DEFINE(ME)
     fi]
 )
-AM_CONDITIONAL(USE_P2P, test x$p2p = xtrue)
+AM_CONDITIONAL(USE_ME, test x$me = xtrue)
 
 AC_ARG_ENABLE(
     [integrity-test],
index 0c8650d..2ce3dfa 100644 (file)
@@ -98,13 +98,13 @@ else
   charon_SOURCES += network/socket.c
 endif
 
-if USE_P2P
+if USE_ME
   charon_SOURCES += encoding/payloads/endpoint_notify.c encoding/payloads/endpoint_notify.h \
     processing/jobs/initiate_mediation_job.c processing/jobs/initiate_mediation_job.h \
     processing/jobs/mediation_job.c processing/jobs/mediation_job.h \
     sa/connect_manager.c sa/connect_manager.h \
     sa/mediation_manager.c sa/mediation_manager.h \
-    sa/tasks/ike_p2p.c sa/tasks/ike_p2p.h
+    sa/tasks/ike_me.c sa/tasks/ike_me.h
 endif
 
 INCLUDES = -I${linuxdir} -I$(top_srcdir)/src/libstrongswan -I$(top_srcdir)/src/charon
index 3b6febc..9e11f88 100644 (file)
@@ -165,23 +165,23 @@ struct private_peer_cfg_t {
         */
        auth_info_t *auth;
 
-#ifdef P2P     
+#ifdef ME      
        /**
         * Is this a mediation connection?
         */
-       bool p2p_mediation;
+       bool mediation;
        
        /**
         * Name of the mediation connection to mediate through
         */
-       peer_cfg_t *p2p_mediated_by;
+       peer_cfg_t *mediated_by;
        
        /**
         * ID of our peer at the mediation server (= leftid of the peer's conn with
         * the mediation server)
         */
        identification_t *peer_id;
-#endif /* P2P */
+#endif /* ME */
 };
 
 /**
@@ -435,13 +435,13 @@ static auth_info_t* get_auth(private_peer_cfg_t *this)
        return this->auth;
 }
 
-#ifdef P2P
+#ifdef ME
 /**
  * Implementation of peer_cfg_t.is_mediation.
  */
 static bool is_mediation(private_peer_cfg_t *this)
 {
-       return this->p2p_mediation;
+       return this->mediation;
 }
 
 /**
@@ -449,9 +449,9 @@ static bool is_mediation(private_peer_cfg_t *this)
  */
 static peer_cfg_t* get_mediated_by(private_peer_cfg_t *this)
 {
-       if (this->p2p_mediated_by) {
-               this->p2p_mediated_by->get_ref(this->p2p_mediated_by);
-               return this->p2p_mediated_by;
+       if (this->mediated_by) {
+               this->mediated_by->get_ref(this->mediated_by);
+               return this->mediated_by;
        }
        return NULL;
 }
@@ -463,7 +463,7 @@ static identification_t* get_peer_id(private_peer_cfg_t *this)
 {
        return this->peer_id;
 }
-#endif /* P2P */
+#endif /* ME */
 
 /**
  * Implementation of peer_cfg_t.equals.
@@ -502,13 +502,13 @@ static bool equals(private_peer_cfg_t *this, private_peer_cfg_t *other)
                 (this->other_virtual_ip && other->other_virtual_ip &&
                  this->other_virtual_ip->equals(this->other_virtual_ip, other->other_virtual_ip))) &&
                this->auth->equals(this->auth, other->auth) 
-#ifdef P2P
-               && this->p2p_mediation == other->p2p_mediation &&
-               this->p2p_mediated_by == other->p2p_mediated_by &&
+#ifdef ME
+               && this->mediation == other->mediation &&
+               this->mediated_by == other->mediated_by &&
                (this->peer_id == other->peer_id ||
                 (this->peer_id && other->peer_id &&
                  this->peer_id->equals(this->peer_id, other->peer_id)))
-#endif /* P2P */
+#endif /* ME */
                );
 }
 
@@ -534,10 +534,10 @@ static void destroy(private_peer_cfg_t *this)
                DESTROY_IF(this->my_virtual_ip);
                DESTROY_IF(this->other_virtual_ip);
                this->auth->destroy(this->auth);
-#ifdef P2P
-               DESTROY_IF(this->p2p_mediated_by);
+#ifdef ME
+               DESTROY_IF(this->mediated_by);
                DESTROY_IF(this->peer_id);
-#endif /* P2P */
+#endif /* ME */
                free(this->name);
                free(this);
        }
@@ -556,7 +556,7 @@ peer_cfg_t *peer_cfg_create(char *name, u_int ike_version, ike_cfg_t *ike_cfg,
                                                        u_int32_t over_time, bool mobike,
                                                        u_int32_t dpd_delay, dpd_action_t dpd_action,
                                                        host_t *my_virtual_ip, host_t *other_virtual_ip,
-                                                       bool p2p_mediation, peer_cfg_t *p2p_mediated_by,
+                                                       bool mediation, peer_cfg_t *mediated_by,
                                                        identification_t *peer_id)
 {
        private_peer_cfg_t *this = malloc_thing(private_peer_cfg_t);
@@ -587,11 +587,11 @@ peer_cfg_t *peer_cfg_create(char *name, u_int ike_version, ike_cfg_t *ike_cfg,
        this->public.equals = (bool(*)(peer_cfg_t*, peer_cfg_t *other))equals;
        this->public.get_ref = (void(*)(peer_cfg_t *))get_ref;
        this->public.destroy = (void(*)(peer_cfg_t *))destroy;
-#ifdef P2P     
+#ifdef ME
        this->public.is_mediation = (bool (*) (peer_cfg_t *))is_mediation;
        this->public.get_mediated_by = (peer_cfg_t* (*) (peer_cfg_t *))get_mediated_by;
        this->public.get_peer_id = (identification_t* (*) (peer_cfg_t *))get_peer_id;
-#endif /* P2P */
+#endif /* ME */
        
        /* apply init values */
        this->name = strdup(name);
@@ -625,14 +625,14 @@ peer_cfg_t *peer_cfg_create(char *name, u_int ike_version, ike_cfg_t *ike_cfg,
        this->other_virtual_ip = other_virtual_ip;
        this->auth = auth_info_create();
        this->refcount = 1;
-#ifdef P2P
-       this->p2p_mediation = p2p_mediation;
-       this->p2p_mediated_by = p2p_mediated_by;
+#ifdef ME
+       this->mediation = mediation;
+       this->mediated_by = mediated_by;
        this->peer_id = peer_id;
-#else /* P2P */
-       DESTROY_IF(p2p_mediated_by);
+#else /* ME */
+       DESTROY_IF(mediated_by);
        DESTROY_IF(peer_id);
-#endif /* P2P */
+#endif /* ME */
 
        return &this->public;
 }
index 2053ce8..e8c0e60 100644 (file)
@@ -292,7 +292,7 @@ struct peer_cfg_t {
         */
        host_t* (*get_other_virtual_ip) (peer_cfg_t *this, host_t *suggestion);
        
-#ifdef P2P     
+#ifdef ME
        /**
         * Is this a mediation connection?
         * 
@@ -318,7 +318,7 @@ struct peer_cfg_t {
         * @return                              the id of the other peer
         */
        identification_t* (*get_peer_id) (peer_cfg_t *this);
-#endif /* P2P */
+#endif /* ME */
 
        /**
         * Check if two peer configurations are equal.
@@ -380,8 +380,8 @@ struct peer_cfg_t {
  * @param dpd_action           what to do with CHILD_SAs when detected a dead peer
  * @param my_virtual_ip                virtual IP for local host, or NULL
  * @param other_virtual_ip     virtual IP for remote host, or NULL
- * @param p2p_mediation                TRUE if this is a mediation connection
- * @param p2p_mediated_by      name of the mediation connection to mediate through
+ * @param mediation                    TRUE if this is a mediation connection
+ * @param mediated_by          peer_cfg_t of the mediation connection to mediate through
  * @param peer_id                      ID that identifies our peer at the mediation server
  * @return                                     peer_cfg_t object
  */
@@ -395,7 +395,7 @@ peer_cfg_t *peer_cfg_create(char *name, u_int ikev_version, ike_cfg_t *ike_cfg,
                                                        u_int32_t over_time, bool mobike,
                                                        u_int32_t dpd_delay, dpd_action_t dpd_action,
                                                        host_t *my_virtual_ip, host_t *other_virtual_ip,
-                                                       bool p2p_mediation, peer_cfg_t *p2p_mediated_by,
+                                                       bool mediation, peer_cfg_t *mediated_by,
                                                        identification_t *peer_id);
 
 #endif /* PEER_CFG_H_ @} */
index 122c5cf..cc41b14 100644 (file)
@@ -180,10 +180,10 @@ static void destroy(private_daemon_t *this)
        DESTROY_IF(this->public.scheduler);
        DESTROY_IF(this->public.controller);
        DESTROY_IF(this->public.eap);
-#ifdef P2P     
+#ifdef ME
        DESTROY_IF(this->public.connect_manager);
        DESTROY_IF(this->public.mediation_manager);
-#endif /* P2P */
+#endif /* ME */
        DESTROY_IF(this->public.backends);
        DESTROY_IF(this->public.credentials);
        DESTROY_IF(this->public.sender);
@@ -348,14 +348,14 @@ static bool initialize(private_daemon_t *this, bool syslog, level_t levels[])
                return FALSE;
        }
        
-#ifdef P2P
+#ifdef ME
        this->public.connect_manager = connect_manager_create();
        if (this->public.connect_manager == NULL)
        {
                return FALSE;
        }
        this->public.mediation_manager = mediation_manager_create();
-#endif /* P2P */
+#endif /* ME */
 
        this->public.plugins->load(this->public.plugins, IPSEC_PLUGINDIR, "libcharon-");
        
index b9c84b2..9dc2947 100644 (file)
@@ -161,10 +161,10 @@ typedef struct daemon_t daemon_t;
 #include <sa/authenticators/eap/eap_manager.h>
 #include <plugins/plugin_loader.h>
 
-#ifdef P2P
+#ifdef ME
 #include <sa/connect_manager.h>
 #include <sa/mediation_manager.h>
-#endif /* P2P */
+#endif /* ME */
 
 /**
  * Name of the daemon.
@@ -277,7 +277,7 @@ struct daemon_t {
         */
        eap_manager_t *eap;
        
-#ifdef P2P
+#ifdef ME
        /**
         * Connect manager
         */
@@ -287,7 +287,7 @@ struct daemon_t {
         * Mediation manager
         */
        mediation_manager_t *mediation_manager;
-#endif /* P2P */
+#endif /* ME */
        
        /**
         * Shut down the daemon.
index 88dafa0..42d169f 100644 (file)
@@ -207,7 +207,7 @@ static payload_rule_t ike_auth_i_payload_rules[] = {
        {CERTIFICATE,                                   0,      4,                                              TRUE,   FALSE},
        {CERTIFICATE_REQUEST,                   0,      1,                                              TRUE,   FALSE},
        {ID_RESPONDER,                                  0,      1,                                              TRUE,   FALSE},
-#ifdef P2P
+#ifdef ME
        {SECURITY_ASSOCIATION,                  0,      1,                                              TRUE,   FALSE},
        {TRAFFIC_SELECTOR_INITIATOR,    0,      1,                                              TRUE,   FALSE},
        {TRAFFIC_SELECTOR_RESPONDER,    0,      1,                                              TRUE,   FALSE},
@@ -215,7 +215,7 @@ static payload_rule_t ike_auth_i_payload_rules[] = {
        {SECURITY_ASSOCIATION,                  1,      1,                                              TRUE,   FALSE},
        {TRAFFIC_SELECTOR_INITIATOR,    1,      1,                                              TRUE,   FALSE},
        {TRAFFIC_SELECTOR_RESPONDER,    1,      1,                                              TRUE,   FALSE},
-#endif /* P2P */
+#endif /* ME */
        {CONFIGURATION,                                 0,      1,                                              TRUE,   FALSE},
        {VENDOR_ID,                                             0,      10,                                             TRUE,   FALSE},
 };
@@ -400,11 +400,11 @@ static payload_order_t create_child_sa_r_payload_order[] = {
        {NOTIFY,                                                0},
 };
 
-#ifdef P2P
+#ifdef ME
 /**
- * Message rule for P2P_CONNECT from initiator.
+ * Message rule for ME_CONNECT from initiator.
  */
-static payload_rule_t p2p_connect_i_payload_rules[] = {
+static payload_rule_t me_connect_i_payload_rules[] = {
 /*     payload type                                    min     max                                             encr    suff */
        {NOTIFY,                                                0,      MAX_NOTIFY_PAYLOADS,    TRUE,   TRUE},
        {ID_PEER,                                               1,      1,                                              TRUE,   FALSE},
@@ -412,9 +412,9 @@ static payload_rule_t p2p_connect_i_payload_rules[] = {
 };
 
 /**
- * payload order for P2P_CONNECT from initiator.
+ * payload order for ME_CONNECT from initiator.
  */
-static payload_order_t p2p_connect_i_payload_order[] = {
+static payload_order_t me_connect_i_payload_order[] = {
 /*     payload type                                    notify type */
        {NOTIFY,                                                0},
        {ID_PEER,                                               0},
@@ -422,23 +422,23 @@ static payload_order_t p2p_connect_i_payload_order[] = {
 };
 
 /**
- * Message rule for P2P_CONNECT from responder.
+ * Message rule for ME_CONNECT from responder.
  */
-static payload_rule_t p2p_connect_r_payload_rules[] = {
+static payload_rule_t me_connect_r_payload_rules[] = {
 /*     payload type                                    min     max                                             encr    suff */
        {NOTIFY,                                                0,      MAX_NOTIFY_PAYLOADS,    TRUE,   TRUE},
        {VENDOR_ID,                                             0,      10,                                             TRUE,   FALSE}
 };
 
 /**
- * payload order for P2P_CONNECT from responder.
+ * payload order for ME_CONNECT from responder.
  */
-static payload_order_t p2p_connect_r_payload_order[] = {
+static payload_order_t me_connect_r_payload_order[] = {
 /*     payload type                                    notify type */
        {NOTIFY,                                                0},
        {VENDOR_ID,                                             0},
 };
-#endif /* P2P */
+#endif /* ME */
 
 /**
  * Message rules, defines allowed payloads.
@@ -492,20 +492,20 @@ static message_rule_t message_rules[] = {
                (sizeof(create_child_sa_r_payload_order)/sizeof(payload_order_t)),
                create_child_sa_r_payload_order,
        },
-#ifdef P2P
-       {P2P_CONNECT,           TRUE,   TRUE,
-               (sizeof(p2p_connect_i_payload_rules)/sizeof(payload_rule_t)),
-               p2p_connect_i_payload_rules,
-               (sizeof(p2p_connect_i_payload_order)/sizeof(payload_order_t)),
-               p2p_connect_i_payload_order,
+#ifdef ME
+       {ME_CONNECT,            TRUE,   TRUE,
+               (sizeof(me_connect_i_payload_rules)/sizeof(payload_rule_t)),
+               me_connect_i_payload_rules,
+               (sizeof(me_connect_i_payload_order)/sizeof(payload_order_t)),
+               me_connect_i_payload_order,
        },
-       {P2P_CONNECT,           FALSE,  TRUE,
-               (sizeof(p2p_connect_r_payload_rules)/sizeof(payload_rule_t)),
-               p2p_connect_r_payload_rules,
-               (sizeof(p2p_connect_r_payload_order)/sizeof(payload_order_t)),
-               p2p_connect_r_payload_order,
+       {ME_CONNECT,            FALSE,  TRUE,
+               (sizeof(me_connect_r_payload_rules)/sizeof(payload_rule_t)),
+               me_connect_r_payload_rules,
+               (sizeof(me_connect_r_payload_order)/sizeof(payload_order_t)),
+               me_connect_r_payload_order,
        },
-#endif /* P2P */       
+#endif /* ME */        
 };
 
 
index bef51a2..ed5378e 100644 (file)
@@ -41,12 +41,12 @@ struct private_endpoint_notify_t {
        /**
         * Family
         */
-       p2p_endpoint_family_t family;
+       me_endpoint_family_t family;
                
        /**
         * Endpoint type
         */
-       p2p_endpoint_type_t type;
+       me_endpoint_type_t type;
        
        /**
         * Endpoint
@@ -71,7 +71,7 @@ struct private_endpoint_notify_t {
       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 */
 
-ENUM(p2p_endpoint_type_names, HOST, RELAYED,
+ENUM(me_endpoint_type_names, HOST, RELAYED,
        "HOST",
        "SERVER_REFLEXIVE",
        "PEER_REFLEXIVE",
@@ -115,7 +115,7 @@ static status_t parse_uint32(u_int8_t **cur, u_int8_t *top, u_int32_t *val)
 }
 
 /**
- * Parses the notification data of a P2P_ENDPOINT notify
+ * Parses the notification data of a ME_ENDPOINT notify
  */
 static status_t parse_notification_data(private_endpoint_notify_t *this, chunk_t data)
 {
@@ -125,29 +125,29 @@ static status_t parse_notification_data(private_endpoint_notify_t *this, chunk_t
        u_int8_t *cur = data.ptr;
        u_int8_t *top = data.ptr + data.len;
        
-       DBG3(DBG_IKE, "p2p_endpoint_data %B", &data);
+       DBG3(DBG_IKE, "me_endpoint_data %B", &data);
        
        if (parse_uint32(&cur, top, &this->priority) != SUCCESS)
        {
-               DBG1(DBG_IKE, "failed to parse P2P_ENDPOINT: invalid priority");
+               DBG1(DBG_IKE, "failed to parse ME_ENDPOINT: invalid priority");
                return FAILED;
        }
 
        if (parse_uint8(&cur, top, &family) != SUCCESS || family >= MAX_FAMILY)
        {
-               DBG1(DBG_IKE, "failed to parse P2P_ENDPOINT: invalid family");
+               DBG1(DBG_IKE, "failed to parse ME_ENDPOINT: invalid family");
                return FAILED;
        }
        
-       this->family = (p2p_endpoint_family_t)family;
+       this->family = (me_endpoint_family_t)family;
        
        if (parse_uint8(&cur, top, &type) != SUCCESS || type >= MAX_TYPE)
        {
-               DBG1(DBG_IKE, "failed to parse P2P_ENDPOINT: invalid type");
+               DBG1(DBG_IKE, "failed to parse ME_ENDPOINT: invalid type");
                return FAILED;
        }
        
-       this->type = (p2p_endpoint_type_t)type;
+       this->type = (me_endpoint_type_t)type;
        
        addr_family = AF_INET;
        addr.len = 4;
@@ -161,13 +161,13 @@ static status_t parse_notification_data(private_endpoint_notify_t *this, chunk_t
                case IPv4:
                        if (parse_uint16(&cur, top, &port) != SUCCESS)
                        {
-                               DBG1(DBG_IKE, "failed to parse P2P_ENDPOINT: invalid port");
+                               DBG1(DBG_IKE, "failed to parse ME_ENDPOINT: invalid port");
                                return FAILED;  
                        }
                        
                        if (cur + addr.len > top)
                        {
-                               DBG1(DBG_IKE, "failed to parse P2P_ENDPOINT: invalid IP address");
+                               DBG1(DBG_IKE, "failed to parse ME_ENDPOINT: invalid IP address");
                                return FAILED;
                        }
                        
@@ -185,7 +185,7 @@ static status_t parse_notification_data(private_endpoint_notify_t *this, chunk_t
 
 
 /**
- * Generates the notification data of a P2P_ENDPOINT notify
+ * Generates the notification data of a ME_ENDPOINT notify
  */
 static chunk_t build_notification_data(private_endpoint_notify_t *this)
 {
@@ -217,7 +217,7 @@ static chunk_t build_notification_data(private_endpoint_notify_t *this)
        /* data = prio | family | type | port | addr */
        data = chunk_cat("ccccc", prio_chunk, family_chunk, type_chunk,
                        port_chunk, addr_chunk);
-       DBG3(DBG_IKE, "p2p_endpoint_data %B", &data);
+       DBG3(DBG_IKE, "me_endpoint_data %B", &data);
        
        return data;
 }
@@ -231,7 +231,7 @@ static notify_payload_t *build_notify(private_endpoint_notify_t *this)
        notify_payload_t *notify;       
        
        notify = notify_payload_create();
-       notify->set_notify_type(notify, P2P_ENDPOINT);
+       notify->set_notify_type(notify, ME_ENDPOINT);
        data = build_notification_data(this);
        notify->set_notification_data(notify, data);
        chunk_free(&data);
@@ -258,7 +258,7 @@ static void set_priority(private_endpoint_notify_t *this, u_int32_t priority)
 /**
  * Implementation of endpoint_notify_t.get_type.
  */
-static p2p_endpoint_type_t get_type(private_endpoint_notify_t *this)
+static me_endpoint_type_t get_type(private_endpoint_notify_t *this)
 {
        return this->type;
 }
@@ -266,7 +266,7 @@ static p2p_endpoint_type_t get_type(private_endpoint_notify_t *this)
 /**
  * Implementation of endpoint_notify_t.get_family.
  */
-static p2p_endpoint_family_t get_family(private_endpoint_notify_t *this)
+static me_endpoint_family_t get_family(private_endpoint_notify_t *this)
 {
        return this->family;
 }
@@ -330,8 +330,8 @@ endpoint_notify_t *endpoint_notify_create()
        /* public functions */
        this->public.get_priority = (u_int32_t (*) (endpoint_notify_t *)) get_priority;
        this->public.set_priority = (void (*) (endpoint_notify_t *, u_int32_t)) set_priority;
-       this->public.get_type = (p2p_endpoint_type_t (*) (endpoint_notify_t *)) get_type;
-       this->public.get_family = (p2p_endpoint_family_t (*) (endpoint_notify_t *)) get_family;
+       this->public.get_type = (me_endpoint_type_t (*) (endpoint_notify_t *)) get_type;
+       this->public.get_family = (me_endpoint_family_t (*) (endpoint_notify_t *)) get_family;
        this->public.get_host = (host_t *(*) (endpoint_notify_t *)) get_host;
        this->public.get_base = (host_t *(*) (endpoint_notify_t *)) get_base;
        this->public.build_notify = (notify_payload_t *(*) (endpoint_notify_t *)) build_notify;
@@ -351,7 +351,7 @@ endpoint_notify_t *endpoint_notify_create()
 /**
  * Described in header
  */
-endpoint_notify_t *endpoint_notify_create_from_host(p2p_endpoint_type_t type, host_t *host, host_t *base)
+endpoint_notify_t *endpoint_notify_create_from_host(me_endpoint_type_t type, host_t *host, host_t *base)
 {
        private_endpoint_notify_t *this = (private_endpoint_notify_t*)endpoint_notify_create();
        
@@ -360,17 +360,17 @@ endpoint_notify_t *endpoint_notify_create_from_host(p2p_endpoint_type_t type, ho
        switch(type)
        {
                case HOST:
-                       this->priority = pow(2, 16) * P2P_PRIO_HOST; 
+                       this->priority = pow(2, 16) * ME_PRIO_HOST; 
                        break;
                case SERVER_REFLEXIVE:
-                       this->priority = pow(2, 16) * P2P_PRIO_SERVER; 
+                       this->priority = pow(2, 16) * ME_PRIO_SERVER; 
                        break;
                case PEER_REFLEXIVE:
-                       this->priority = pow(2, 16) * P2P_PRIO_PEER; 
+                       this->priority = pow(2, 16) * ME_PRIO_PEER; 
                        break;
                case RELAYED:
                default:
-                       this->priority = pow(2, 16) * P2P_PRIO_RELAY; 
+                       this->priority = pow(2, 16) * ME_PRIO_RELAY; 
                        break;
        }
        
@@ -410,7 +410,7 @@ endpoint_notify_t *endpoint_notify_create_from_host(p2p_endpoint_type_t type, ho
  */
 endpoint_notify_t *endpoint_notify_create_from_payload(notify_payload_t *notify)
 {
-       if (notify->get_notify_type(notify) != P2P_ENDPOINT)
+       if (notify->get_notify_type(notify) != ME_ENDPOINT)
        {
                return NULL;
        }
index 9203dc8..88b63a6 100644 (file)
 #ifndef ENDPOINT_NOTIFY_H_
 #define ENDPOINT_NOTIFY_H_
 
-#define P2P_PRIO_HOST   255
-#define P2P_PRIO_SERVER 100
-#define P2P_PRIO_PEER   120
-#define P2P_PRIO_RELAY  0
+#define ME_PRIO_HOST   255
+#define ME_PRIO_SERVER 100
+#define ME_PRIO_PEER   120
+#define ME_PRIO_RELAY  0
 
-typedef enum p2p_endpoint_family_t p2p_endpoint_family_t;
-typedef enum p2p_endpoint_type_t p2p_endpoint_type_t;
+typedef enum me_endpoint_family_t me_endpoint_family_t;
+typedef enum me_endpoint_type_t me_endpoint_type_t;
 typedef struct endpoint_notify_t endpoint_notify_t;
 
 #include <encoding/payloads/notify_payload.h>
 
 /**
- * P2P endpoint families.
+ * ME endpoint families.
  */
-enum p2p_endpoint_family_t {
+enum me_endpoint_family_t {
        
        NO_FAMILY = 0,
        
@@ -50,9 +50,9 @@ enum p2p_endpoint_family_t {
 };
 
 /**
- * P2P endpoint types.
+ * ME endpoint types.
  */
-enum p2p_endpoint_type_t {
+enum me_endpoint_type_t {
        
        NO_TYPE = 0,
        
@@ -69,12 +69,12 @@ enum p2p_endpoint_type_t {
 };
 
 /**
- * enum name for p2p_endpoint_type_t.
+ * enum name for me_endpoint_type_t.
  */
-extern enum_name_t *p2p_endpoint_type_names;
+extern enum_name_t *me_endpoint_type_names;
 
 /**
- * Class representing a P2P_ENDPOINT notify. In fact it's not
+ * Class representing a ME_ENDPOINT Notify payload. In fact it's not
  * the notify per se, but the notification data of that notify that is
  * handled with this class.
  */
@@ -98,14 +98,14 @@ struct endpoint_notify_t {
         * 
         * @return                      endpoint type
         */
-       p2p_endpoint_type_t (*get_type) (endpoint_notify_t *this);
+       me_endpoint_type_t (*get_type) (endpoint_notify_t *this);
        
        /**
         * Returns the endpoint family of this endpoint.
         * 
         * @return                      endpoint family
         */
-       p2p_endpoint_family_t (*get_family) (endpoint_notify_t *this);
+       me_endpoint_family_t (*get_family) (endpoint_notify_t *this);
        
        /**
         * Returns the host of this endpoint.
@@ -160,7 +160,7 @@ endpoint_notify_t *endpoint_notify_create(void);
  * @param base         base of the endpoint, applies only to reflexive endpoints (gets cloned)
  * @return                     created endpoint_notify_t object
  */
-endpoint_notify_t *endpoint_notify_create_from_host(p2p_endpoint_type_t type,
+endpoint_notify_t *endpoint_notify_create_from_host(me_endpoint_type_t type,
                                                                                                        host_t *host, host_t *base);
 
 /**
index dbe0ee2..9cc5567 100644 (file)
@@ -105,13 +105,13 @@ ENUM_NEXT(exchange_type_names, IKE_SA_INIT, INFORMATIONAL, EXCHANGE_TYPE_UNDEFIN
        "IKE_AUTH",
        "CREATE_CHILD_SA",
        "INFORMATIONAL");
-#ifdef P2P
-ENUM_NEXT(exchange_type_names, P2P_CONNECT, P2P_CONNECT, INFORMATIONAL,
-       "P2P_CONNECT");
-ENUM_END(exchange_type_names, P2P_CONNECT);
+#ifdef ME
+ENUM_NEXT(exchange_type_names, ME_CONNECT, ME_CONNECT, INFORMATIONAL,
+       "ME_CONNECT");
+ENUM_END(exchange_type_names, ME_CONNECT);
 #else
 ENUM_END(exchange_type_names, INFORMATIONAL);
-#endif /* P2P */
+#endif /* ME */
 
 /**
  * Encoding rules to parse or generate a IKEv2-Header.
@@ -176,9 +176,9 @@ static status_t verify(private_ike_header_t *this)
 {
        if ((this->exchange_type < IKE_SA_INIT) ||
                ((this->exchange_type > INFORMATIONAL)
-#ifdef P2P
-                       && (this->exchange_type != P2P_CONNECT)
-#endif /* P2P */
+#ifdef ME
+                       && (this->exchange_type != ME_CONNECT)
+#endif /* ME */
                ))
        {
                /* unsupported exchange type */
@@ -186,11 +186,11 @@ static status_t verify(private_ike_header_t *this)
        }
 
        if (this->initiator_spi == 0
-#ifdef P2P
+#ifdef ME
                /* we allow zero spi for INFORMATIONAL exchanges,
-                * to allow P2P connectivity checks */
+                * to allow connectivity checks */
                && this->exchange_type != INFORMATIONAL
-#endif /* P2P */
+#endif /* ME */
                )
        {
                /* initiator spi not set */
index d66db93..06ee328 100644 (file)
@@ -82,12 +82,12 @@ enum exchange_type_t{
         * INFORMATIONAL.
         */
        INFORMATIONAL = 37,
-#ifdef P2P
+#ifdef ME
        /**
-        * P2P_CONNECT
+        * ME_CONNECT
         */
-       P2P_CONNECT = 240
-#endif /* P2P */
+       ME_CONNECT = 240
+#endif /* ME */
 };
 
 /**
index 0950f6b..975cc6d 100644 (file)
@@ -52,9 +52,9 @@ ENUM_NEXT(notify_type_names, SINGLE_PAIR_REQUIRED, UNEXPECTED_NAT_DETECTED, AUTH
        "INVALID_SELECTORS",
        "UNACCEPTABLE_ADDRESSES",
        "UNEXPECTED_NAT_DETECTED");
-ENUM_NEXT(notify_type_names, P2P_CONNECT_FAILED, P2P_CONNECT_FAILED, UNEXPECTED_NAT_DETECTED,
-       "P2P_CONNECT_FAILED");
-ENUM_NEXT(notify_type_names, INITIAL_CONTACT, AUTH_LIFETIME, P2P_CONNECT_FAILED,
+ENUM_NEXT(notify_type_names, ME_CONNECT_FAILED, ME_CONNECT_FAILED, UNEXPECTED_NAT_DETECTED,
+       "ME_CONNECT_FAILED");
+ENUM_NEXT(notify_type_names, INITIAL_CONTACT, AUTH_LIFETIME, ME_CONNECT_FAILED,
        "INITIAL_CONTACT",
        "SET_WINDOW_SIZE",
        "ADDITIONAL_TS_POSSIBLE",
@@ -79,14 +79,14 @@ ENUM_NEXT(notify_type_names, EAP_ONLY_AUTHENTICATION, EAP_ONLY_AUTHENTICATION, A
        "EAP_ONLY_AUTHENTICATION");
 ENUM_NEXT(notify_type_names, USE_BEET_MODE, USE_BEET_MODE, EAP_ONLY_AUTHENTICATION,
        "USE_BEET_MODE");
-ENUM_NEXT(notify_type_names, P2P_MEDIATION, P2P_RESPONSE, USE_BEET_MODE,
-       "P2P_MEDIATION",
-       "P2P_ENDPOINT",
-       "P2P_CALLBACK",
-       "P2P_SESSIONID",
-       "P2P_SESSIONKEY",
-       "P2P_RESPONSE");
-ENUM_END(notify_type_names, P2P_RESPONSE);
+ENUM_NEXT(notify_type_names, ME_MEDIATION, ME_RESPONSE, USE_BEET_MODE,
+       "ME_MEDIATION",
+       "ME_ENDPOINT",
+       "ME_CALLBACK",
+       "ME_CONNECTID",
+       "ME_CONNECTKEY",
+       "ME_RESPONSE");
+ENUM_END(notify_type_names, ME_RESPONSE);
 
 
 ENUM_BEGIN(notify_type_short_names, UNSUPPORTED_CRITICAL_PAYLOAD, UNSUPPORTED_CRITICAL_PAYLOAD,
@@ -115,9 +115,9 @@ ENUM_NEXT(notify_type_short_names, SINGLE_PAIR_REQUIRED, UNEXPECTED_NAT_DETECTED
        "INVAL_SEL",
        "UNACCEPT_ADDR",
        "UNEXPECT_NAT");
-ENUM_NEXT(notify_type_short_names, P2P_CONNECT_FAILED, P2P_CONNECT_FAILED, UNEXPECTED_NAT_DETECTED,
-       "P2P_CONN_FAIL");
-ENUM_NEXT(notify_type_short_names, INITIAL_CONTACT, AUTH_LIFETIME, P2P_CONNECT_FAILED,
+ENUM_NEXT(notify_type_short_names, ME_CONNECT_FAILED, ME_CONNECT_FAILED, UNEXPECTED_NAT_DETECTED,
+       "ME_CONN_FAIL");
+ENUM_NEXT(notify_type_short_names, INITIAL_CONTACT, AUTH_LIFETIME, ME_CONNECT_FAILED,
        "INIT_CONTACT",
        "SET_WINSIZE",
        "ADD_TS_POSS",
@@ -142,14 +142,14 @@ ENUM_NEXT(notify_type_short_names, EAP_ONLY_AUTHENTICATION, EAP_ONLY_AUTHENTICAT
        "EAP_ONLY");
 ENUM_NEXT(notify_type_short_names, USE_BEET_MODE, USE_BEET_MODE, EAP_ONLY_AUTHENTICATION,
        "BEET_MODE");
-ENUM_NEXT(notify_type_short_names, P2P_MEDIATION, P2P_RESPONSE, USE_BEET_MODE,
-       "P2P_MED",
-       "P2P_EP",
-       "P2P_CB",
-       "P2P_SID",
-       "P2P_SKEY",
-       "P2P_R");
-ENUM_END(notify_type_short_names, P2P_RESPONSE);
+ENUM_NEXT(notify_type_short_names, ME_MEDIATION, ME_RESPONSE, USE_BEET_MODE,
+       "ME_MED",
+       "ME_EP",
+       "ME_CB",
+       "ME_CID",
+       "ME_CKEY",
+       "ME_R");
+ENUM_END(notify_type_short_names, ME_RESPONSE);
 
 
 typedef struct private_notify_payload_t private_notify_payload_t;
@@ -329,7 +329,7 @@ static status_t verify(private_notify_payload_t *this)
                        }
                        break;
                }
-               /* FIXME: check size of P2P-NAT-T payloads */
+               /* FIXME: check size of IKE-ME payloads */
                default:
                        /* TODO: verify */
                        break;
index 2f147c9..5677bb5 100644 (file)
@@ -63,8 +63,8 @@ enum notify_type_t {
        INVALID_SELECTORS = 39,
        UNACCEPTABLE_ADDRESSES = 40,
        UNEXPECTED_NAT_DETECTED = 41,
-       /* P2P-NAT-T, private use */
-       P2P_CONNECT_FAILED = 8192,
+       /* IKE-ME, private use */
+       ME_CONNECT_FAILED = 8192,
        
        /* notify status messages */
        INITIAL_CONTACT = 16384,
@@ -93,13 +93,13 @@ enum notify_type_t {
        EAP_ONLY_AUTHENTICATION = 40960,
        /* BEET mode, not even a draft yet. private use */
        USE_BEET_MODE = 40961,
-       /* P2P-NAT-T, private use */
-       P2P_MEDIATION = 40962,
-       P2P_ENDPOINT = 40963,
-       P2P_CALLBACK = 40964,
-       P2P_SESSIONID = 40965,
-       P2P_SESSIONKEY = 40966,
-       P2P_RESPONSE = 40967
+       /* IKE-ME, private use */
+       ME_MEDIATION = 40962,
+       ME_ENDPOINT = 40963,
+       ME_CALLBACK = 40964,
+       ME_CONNECTID = 40965,
+       ME_CONNECTKEY = 40966,
+       ME_RESPONSE = 40967
 };
 
 /**
index 6e6a6e2..032de6e 100644 (file)
@@ -58,13 +58,13 @@ ENUM_NEXT(payload_type_names, SECURITY_ASSOCIATION, EXTENSIBLE_AUTHENTICATION, N
        "ENCRYPTED",
        "CONFIGURATION",
        "EXTENSIBLE_AUTHENTICATION");
-#ifdef P2P
+#ifdef ME
 ENUM_NEXT(payload_type_names, ID_PEER, ID_PEER, EXTENSIBLE_AUTHENTICATION,
        "ID_PEER");
 ENUM_NEXT(payload_type_names, HEADER, UNKNOWN_PAYLOAD, ID_PEER,
 #else
 ENUM_NEXT(payload_type_names, HEADER, UNKNOWN_PAYLOAD, EXTENSIBLE_AUTHENTICATION,
-#endif /* P2P */
+#endif /* ME */
        "HEADER",
        "PROPOSAL_SUBSTRUCTURE",
        "TRANSFORM_SUBSTRUCTURE",
@@ -94,13 +94,13 @@ ENUM_NEXT(payload_type_short_names, SECURITY_ASSOCIATION, EXTENSIBLE_AUTHENTICAT
        "E",
        "CP",
        "EAP");
-#ifdef P2P
+#ifdef ME
 ENUM_NEXT(payload_type_short_names, ID_PEER, ID_PEER, EXTENSIBLE_AUTHENTICATION,
        "IDp");
 ENUM_NEXT(payload_type_short_names, HEADER, UNKNOWN_PAYLOAD, ID_PEER,
 #else
 ENUM_NEXT(payload_type_short_names, HEADER, UNKNOWN_PAYLOAD, EXTENSIBLE_AUTHENTICATION,
-#endif /* P2P */
+#endif /* ME */
        "HDR",
        "PROP",
        "TRANS",
@@ -133,10 +133,10 @@ payload_t *payload_create(payload_type_t type)
                        return (payload_t*)id_payload_create(ID_INITIATOR);
                case ID_RESPONDER:
                        return (payload_t*)id_payload_create(ID_RESPONDER);
-#ifdef P2P
+#ifdef ME
                case ID_PEER:
                        return (payload_t*)id_payload_create(ID_PEER);
-#endif /* P2P */
+#endif /* ME */
                case AUTHENTICATION:
                        return (payload_t*)auth_payload_create();
                case CERTIFICATE:
index a2c6e29..28499eb 100644 (file)
@@ -125,13 +125,13 @@ enum payload_type_t{
         */
        EXTENSIBLE_AUTHENTICATION = 48,
        
-#ifdef P2P     
+#ifdef ME
        /**
-        * Identification payload for peers in P2P-NAT-T has a value from
+        * Identification payload for peers has a value from
         * the PRIVATE USE space. 
         */
        ID_PEER = 128,
-#endif /* P2P */
+#endif /* ME */
        
        /**
         * Header has a value of PRIVATE USE space.
index 8c149d0..ef8ceed 100644 (file)
@@ -375,8 +375,8 @@ static peer_cfg_t *build_peer_cfg(private_stroke_config_t *this,
        }
        
        
-#ifdef P2P
-       if (msg->add_conn.p2p.mediation && msg->add_conn.p2p.mediated_by)
+#ifdef ME
+       if (msg->add_conn.ikeme.mediation && msg->add_conn.ikeme.mediated_by)
        {
                DBG1(DBG_CFG, "a mediation connection cannot be a"
                                " mediated connection at the same time, aborting");
@@ -385,14 +385,14 @@ static peer_cfg_t *build_peer_cfg(private_stroke_config_t *this,
                return NULL;
        }
        
-       if (msg->add_conn.p2p.mediated_by)
+       if (msg->add_conn.ikeme.mediated_by)
        {
                mediated_by = charon->backends->get_peer_cfg_by_name(charon->backends,
-                                                                                               msg->add_conn.p2p.mediated_by);
+                                                                                               msg->add_conn.ikeme.mediated_by);
                if (!mediated_by)
                {
                        DBG1(DBG_CFG, "mediation connection '%s' not found, aborting",
-                                msg->add_conn.p2p.mediated_by);
+                                msg->add_conn.ikeme.mediated_by);
                        me->destroy(me);
                        other->destroy(other);
                        return NULL;
@@ -402,7 +402,7 @@ static peer_cfg_t *build_peer_cfg(private_stroke_config_t *this,
                {
                        DBG1(DBG_CFG, "connection '%s' as referred to by '%s' is"
                                 "no mediation connection, aborting", 
-                               msg->add_conn.p2p.mediated_by, msg->add_conn.name);
+                               msg->add_conn.ikeme.mediated_by, msg->add_conn.name);
                        mediated_by->destroy(mediated_by);
                        me->destroy(me);
                        other->destroy(other);
@@ -410,12 +410,12 @@ static peer_cfg_t *build_peer_cfg(private_stroke_config_t *this,
                }
        }
        
-       if (msg->add_conn.p2p.peerid)
+       if (msg->add_conn.ikeme.peerid)
        {
-               peer_id = identification_create_from_string(msg->add_conn.p2p.peerid);
+               peer_id = identification_create_from_string(msg->add_conn.ikeme.peerid);
                if (!peer_id)
                {
-                       DBG1(DBG_CFG, "invalid peer ID: %s\n", msg->add_conn.p2p.peerid);
+                       DBG1(DBG_CFG, "invalid peer ID: %s\n", msg->add_conn.ikeme.peerid);
                        mediated_by->destroy(mediated_by);
                        me->destroy(me);
                        other->destroy(other);
@@ -427,7 +427,7 @@ static peer_cfg_t *build_peer_cfg(private_stroke_config_t *this,
                /* no peer ID supplied, assume right ID */
                peer_id = other->clone(other);
        }
-#endif /* P2P */
+#endif /* ME */
        
        if (msg->add_conn.me.cert)
        {
@@ -471,7 +471,7 @@ static peer_cfg_t *build_peer_cfg(private_stroke_config_t *this,
                msg->add_conn.eap_type, msg->add_conn.eap_vendor,
                msg->add_conn.rekey.tries, rekey, reauth, jitter, over,
                msg->add_conn.mobike, msg->add_conn.dpd.delay, msg->add_conn.dpd.action,
-               my_vip, other_vip, msg->add_conn.p2p.mediation, mediated_by, peer_id);
+               my_vip, other_vip, msg->add_conn.ikeme.mediation, mediated_by, peer_id);
 }
 
 /**
index eda64be..60ea301 100644 (file)
@@ -166,11 +166,11 @@ static void stroke_add_conn(private_stroke_socket_t *this, stroke_msg_t *msg)
        pop_string(msg, &msg->add_conn.algorithms.esp);
        DBG2(DBG_CFG, "  ike=%s", msg->add_conn.algorithms.ike);
        DBG2(DBG_CFG, "  esp=%s", msg->add_conn.algorithms.esp);
-       pop_string(msg, &msg->add_conn.p2p.mediated_by);
-       pop_string(msg, &msg->add_conn.p2p.peerid);
-       DBG2(DBG_CFG, "  p2p_mediation=%s", msg->add_conn.p2p.mediation ? "yes" : "no");
-       DBG2(DBG_CFG, "  p2p_mediated_by=%s", msg->add_conn.p2p.mediated_by);
-       DBG2(DBG_CFG, "  p2p_peerid=%s", msg->add_conn.p2p.peerid);
+       pop_string(msg, &msg->add_conn.ikeme.mediated_by);
+       pop_string(msg, &msg->add_conn.ikeme.peerid);
+       DBG2(DBG_CFG, "  p2p_mediation=%s", msg->add_conn.ikeme.mediation ? "yes" : "no");
+       DBG2(DBG_CFG, "  p2p_mediated_by=%s", msg->add_conn.ikeme.mediated_by);
+       DBG2(DBG_CFG, "  p2p_peerid=%s", msg->add_conn.ikeme.peerid);
 
        this->config->add(this->config, msg);
 }
index 6f3e004..5894b6a 100644 (file)
@@ -43,14 +43,14 @@ struct private_mediation_job_t {
        identification_t *source;
        
        /**
-        * P2P_SESSIONID
+        * ME_CONNECTID
         */
-       chunk_t session_id;
+       chunk_t connect_id;
        
        /**
-        * P2P_SESSIONKEY
+        * ME_CONNECTKEY
         */
-       chunk_t session_key;
+       chunk_t connect_key;
        
        /**
         * Submitted endpoints
@@ -75,8 +75,8 @@ static void destroy(private_mediation_job_t *this)
 {
        DESTROY_IF(this->target);
        DESTROY_IF(this->source);
-       chunk_free(&this->session_id);
-       chunk_free(&this->session_key);
+       chunk_free(&this->connect_id);
+       chunk_free(&this->connect_key);
        DESTROY_OFFSET_IF(this->endpoints, offsetof(endpoint_notify_t, destroy));
        free(this);
 }
@@ -111,8 +111,8 @@ static void execute(private_mediation_job_t *this)
                        else
                        {
                                /* normal mediation between two peers */
-                               if (target_sa->relay(target_sa, this->source, this->session_id,
-                                               this->session_key, this->endpoints, this->response) != SUCCESS)
+                               if (target_sa->relay(target_sa, this->source, this->connect_id,
+                                               this->connect_key, this->endpoints, this->response) != SUCCESS)
                                {
                                        DBG1(DBG_JOB, "mediation between '%D' and '%D' failed",
                                                        this->source, this->target);
@@ -154,8 +154,8 @@ static private_mediation_job_t *mediation_job_create_empty()
        this->target = NULL;
        this->source = NULL;
        this->callback = FALSE;
-       this->session_id = chunk_empty;
-       this->session_key = chunk_empty;
+       this->connect_id = chunk_empty;
+       this->connect_key = chunk_empty;
        this->endpoints = NULL;
        this->response = FALSE;
        
@@ -166,15 +166,15 @@ static private_mediation_job_t *mediation_job_create_empty()
  * Described in header
  */
 mediation_job_t *mediation_job_create(identification_t *peer_id,
-               identification_t *requester, chunk_t session_id, chunk_t session_key,
+               identification_t *requester, chunk_t connect_id, chunk_t connect_key,
                linked_list_t *endpoints, bool response)
 {
        private_mediation_job_t *this = mediation_job_create_empty();
 
        this->target = peer_id->clone(peer_id);
        this->source = requester->clone(requester);
-       this->session_id = chunk_clone(session_id);
-       this->session_key = chunk_clone(session_key);
+       this->connect_id = chunk_clone(connect_id);
+       this->connect_key = chunk_clone(connect_key);
        this->endpoints = endpoints->clone_offset(endpoints, offsetof(endpoint_notify_t, clone));
        this->response = response;
        
index 8bf8a7e..83f1356 100644 (file)
@@ -49,14 +49,14 @@ struct mediation_job_t {
  * 
  * @param peer_id              ID of the requested peer
  * @param requester            ID of the requesting peer
- * @param session_id   content of P2P_SESSIONID (could be NULL)
- * @param session_key  content of P2P_SESSIONKEY
+ * @param connect_id   content of ME_CONNECTID (could be NULL)
+ * @param connect_key  content of ME_CONNECTKEY
  * @param endpoints            list of submitted endpoints
  * @param response             TRUE if this is a response
  * @return                             job object
  */
 mediation_job_t *mediation_job_create(identification_t *peer_id,
-               identification_t *requester, chunk_t session_id, chunk_t session_key,
+               identification_t *requester, chunk_t connect_id, chunk_t connect_key,
                linked_list_t *endpoints, bool response);
 
 
index 9d7ab04..b4fb2ba 100644 (file)
@@ -53,7 +53,7 @@ static void execute(private_process_message_job_t *this)
 {
        ike_sa_t *ike_sa;
        
-#ifdef P2P
+#ifdef ME
        /* if this is an unencrypted INFORMATIONAL exchange it is likely a 
         * connectivity check. */
        if (this->message->get_exchange_type(this->message) == INFORMATIONAL &&
@@ -68,7 +68,7 @@ static void execute(private_process_message_job_t *this)
                destroy(this);
                return;
        }
-#endif /* P2P */
+#endif /* ME */
        
        ike_sa = charon->ike_sa_manager->checkout_by_message(charon->ike_sa_manager,
                                                                                                                 this->message);
index fa5be96..c0f4971 100644 (file)
 #include <encoding/payloads/endpoint_notify.h>
 
 /* base timeout
- * the sending interval is P2P_INTERVAL * active checklists (N)
- * retransmission timeout is P2P_INTERVAL * N * checks in waiting state (NW) */
-#define P2P_INTERVAL 20 /* ms */
-/* min retransmission timeout (RTO is P2P_INTERVAL * N * checks in waiting state) */
-#define P2P_RTO_MIN 100 /* ms */
+ * the sending interval is ME_INTERVAL * active checklists (N)
+ * retransmission timeout is ME_INTERVAL * N * checks in waiting state (NW) */
+#define ME_INTERVAL 20 /* ms */
+/* min retransmission timeout (RTO is ME_INTERVAL * N * checks in waiting state) */
+#define ME_RTO_MIN 100 /* ms */
 /* max number of retransmissions (+ the initial check) */
-#define P2P_MAX_RETRANS 2
+#define ME_MAX_RETRANS 2
 
 
 typedef struct private_connect_manager_t private_connect_manager_t;
@@ -65,7 +65,7 @@ struct private_connect_manager_t {
         linked_list_t *initiated;
         
         /**
-         * Linked list with checklists (hash table with session ID as key would be better).
+         * Linked list with checklists (hash table with connect ID as key would be better).
          */
         linked_list_t *checklists;
 };
@@ -175,8 +175,8 @@ struct check_list_t {
                linked_list_t *endpoints;
        } responder;
        
-       /** session id */
-       chunk_t session_id;
+       /** connect id */
+       chunk_t connect_id;
        
     /** list of endpoint pairs */
     linked_list_t *pairs;
@@ -200,7 +200,7 @@ static void check_list_destroy(check_list_t *this)
        DESTROY_IF(this->initiator.id);
        DESTROY_IF(this->responder.id);
        
-       chunk_free(&this->session_id);
+       chunk_free(&this->connect_id);
        chunk_free(&this->initiator.key);
        chunk_free(&this->responder.key);
        
@@ -218,12 +218,12 @@ static void check_list_destroy(check_list_t *this)
  * Creates a new checklist
  */
 static check_list_t *check_list_create(identification_t *initiator, identification_t *responder,
-               chunk_t session_id, chunk_t initiator_key, linked_list_t *initiator_endpoints,
+               chunk_t connect_id, chunk_t initiator_key, linked_list_t *initiator_endpoints,
                bool is_initiator)
 {
        check_list_t *this = malloc_thing(check_list_t);
        
-       this->session_id = chunk_clone(session_id);
+       this->connect_id = chunk_clone(connect_id);
        
        this->initiator.id = initiator->clone(initiator);
        this->initiator.key = chunk_clone(initiator_key);
@@ -335,8 +335,8 @@ struct check_t {
        /** destination of the connectivity check */
        host_t *dst;
        
-       /** session id */
-       chunk_t session_id;
+       /** connect id */
+       chunk_t connect_id;
        
        /** endpoint */
        endpoint_notify_t *endpoint;
@@ -353,7 +353,7 @@ struct check_t {
  */
 static void check_destroy(check_t *this)
 {
-       chunk_free(&this->session_id);
+       chunk_free(&this->connect_id);
        chunk_free(&this->endpoint_raw);
        chunk_free(&this->cookie);
        DESTROY_IF(this->endpoint);
@@ -367,7 +367,7 @@ static check_t *check_create()
 {
        check_t *this = malloc_thing(check_t);
        
-       this->session_id = chunk_empty;
+       this->connect_id = chunk_empty;
        this->cookie = chunk_empty;
        this->endpoint_raw = chunk_empty;
        this->endpoint = NULL;
@@ -386,8 +386,8 @@ struct sender_data_t {
        /** connect manager */
        private_connect_manager_t *connect_manager;
        
-       /** session id */
-       chunk_t session_id;
+       /** connect id */
+       chunk_t connect_id;
 };
 
 /**
@@ -395,18 +395,18 @@ struct sender_data_t {
  */
 static void sender_data_destroy(sender_data_t *this)
 {
-       chunk_free(&this->session_id);
+       chunk_free(&this->connect_id);
        free(this);
 }
 
 /**
  * Creates a new sender data object
  */
-static sender_data_t *sender_data_create(private_connect_manager_t *connect_manager, chunk_t session_id)
+static sender_data_t *sender_data_create(private_connect_manager_t *connect_manager, chunk_t connect_id)
 {
        sender_data_t *this = malloc_thing(sender_data_t);      
        this->connect_manager = connect_manager;
-       this->session_id = session_id;
+       this->connect_id = connect_id;
        return this;
 }
 
@@ -419,8 +419,8 @@ struct retransmit_data_t {
        /** connect manager */
        private_connect_manager_t *connect_manager;
        
-       /** session id */
-       chunk_t session_id;
+       /** connect id */
+       chunk_t connect_id;
        
        /** message (pair) id */
        u_int32_t mid;
@@ -431,7 +431,7 @@ struct retransmit_data_t {
  */
 static void retransmit_data_destroy(retransmit_data_t *this)
 {
-       chunk_free(&this->session_id);
+       chunk_free(&this->connect_id);
        free(this);
 }
 
@@ -439,12 +439,12 @@ static void retransmit_data_destroy(retransmit_data_t *this)
  * Creates a new retransmission data object
  */
 static retransmit_data_t *retransmit_data_create(private_connect_manager_t *connect_manager,
-               chunk_t session_id, u_int32_t mid)
+               chunk_t connect_id, u_int32_t mid)
 {
        retransmit_data_t *this = malloc_thing(retransmit_data_t);
        
        this->connect_manager = connect_manager;
-       this->session_id = session_id;
+       this->connect_id = connect_id;
        this->mid = mid;
 
        return this;
@@ -539,19 +539,19 @@ static status_t get_waiting_sa(initiated_t *initiated, ike_sa_id_t *ike_sa_id, w
 }
 
 /**
- * Find the checklist with a specific session ID
+ * Find the checklist with a specific connect ID
  */
-static bool match_checklist_by_id(check_list_t *current, chunk_t *session_id)
+static bool match_checklist_by_id(check_list_t *current, chunk_t *connect_id)
 {
-       return chunk_equals(*session_id, current->session_id);
+       return chunk_equals(*connect_id, current->connect_id);
 }
 
 static status_t get_checklist_by_id(private_connect_manager_t *this,
-               chunk_t session_id, check_list_t **check_list)
+               chunk_t connect_id, check_list_t **check_list)
 {
        return this->checklists->find_first(this->checklists,
                                (linked_list_match_t)match_checklist_by_id,
-                               (void**)check_list, &session_id);
+                               (void**)check_list, &connect_id);
 }
 
 /**
@@ -833,34 +833,34 @@ static status_t process_payloads(message_t *message, check_t *check)
                
                switch (notify->get_notify_type(notify))
                {
-                       case P2P_ENDPOINT:
+                       case ME_ENDPOINT:
                        {
                                if (check->endpoint)
                                {
-                                       DBG1(DBG_IKE, "connectivity check contains multiple P2P_ENDPOINT notifies");
+                                       DBG1(DBG_IKE, "connectivity check contains multiple ME_ENDPOINT notifies");
                                        break;
                                }
                                
                                endpoint_notify_t *endpoint = endpoint_notify_create_from_payload(notify);
                                if (!endpoint)
                                {
-                                       DBG1(DBG_IKE, "received invalid P2P_ENDPOINT notify");
+                                       DBG1(DBG_IKE, "received invalid ME_ENDPOINT notify");
                                        break;
                                }
                                check->endpoint = endpoint;
                                check->endpoint_raw = chunk_clone(notify->get_notification_data(notify));
-                               DBG2(DBG_IKE, "received P2P_ENDPOINT notify");
+                               DBG2(DBG_IKE, "received ME_ENDPOINT notify");
                                break;
                        }
-                       case P2P_SESSIONID:
+                       case ME_CONNECTID:
                        {
-                               if (check->session_id.ptr)
+                               if (check->connect_id.ptr)
                                {
-                                       DBG1(DBG_IKE, "connectivity check contains multiple P2P_SESSIONID notifies");
+                                       DBG1(DBG_IKE, "connectivity check contains multiple ME_CONNECTID notifies");
                                        break;
                                }
-                               check->session_id = chunk_clone(notify->get_notification_data(notify));
-                               DBG2(DBG_IKE, "received P2P_SESSIONID %#B", &check->session_id);
+                               check->connect_id = chunk_clone(notify->get_notification_data(notify));
+                               DBG2(DBG_IKE, "received ME_CONNECTID %#B", &check->connect_id);
                                break;
                        }
                        case COOKIE:
@@ -880,7 +880,7 @@ static status_t process_payloads(message_t *message, check_t *check)
        }
        iterator->destroy(iterator);
        
-       if (!check->session_id.ptr || !check->endpoint || !check->cookie.ptr)
+       if (!check->connect_id.ptr || !check->endpoint || !check->cookie.ptr)
        {
                DBG1(DBG_IKE, "at least one payload was missing from the connectivity check");
                return FAILED;
@@ -903,8 +903,8 @@ static chunk_t build_signature(private_connect_manager_t *this,
        key_chunk = (checklist->is_initiator && outbound) || (!checklist->is_initiator && !outbound)
                                        ? checklist->initiator.key : checklist->responder.key;
        
-       /* signature = SHA1( MID | P2P_SESSIONID | P2P_ENDPOINT | P2P_SESSIONKEY ) */
-       sig_chunk = chunk_cat("cccc", mid_chunk, check->session_id, check->endpoint_raw, key_chunk);
+       /* signature = SHA1( MID | ME_CONNECTID | ME_ENDPOINT | ME_CONNECTKEY ) */
+       sig_chunk = chunk_cat("cccc", mid_chunk, check->connect_id, check->endpoint_raw, key_chunk);
        this->hasher->allocate_hash(this->hasher, sig_chunk, &sig_hash);
        DBG3(DBG_IKE, "sig_chunk %B", &sig_chunk);
        DBG3(DBG_IKE, "sig_hash %B", &sig_hash);
@@ -913,7 +913,7 @@ static chunk_t build_signature(private_connect_manager_t *this,
        return sig_hash;
 }
 
-static void queue_retransmission(private_connect_manager_t *this, chunk_t session_id, u_int32_t mid);
+static void queue_retransmission(private_connect_manager_t *this, chunk_t connect_id, u_int32_t mid);
 static void schedule_checks(private_connect_manager_t *this, check_list_t *checklist, u_int32_t time);
 static void finish_checks(private_connect_manager_t *this, check_list_t *checklist);
 
@@ -927,10 +927,10 @@ static job_requeue_t retransmit(retransmit_data_t *data)
        pthread_mutex_lock(&(this->mutex));
 
        check_list_t *checklist;
-       if (get_checklist_by_id(this, data->session_id, &checklist) != SUCCESS)
+       if (get_checklist_by_id(this, data->connect_id, &checklist) != SUCCESS)
        {
                DBG1(DBG_IKE, "checklist with id '%B' not found, can't retransmit connectivity check",
-                               &data->session_id);
+                               &data->connect_id);
                pthread_mutex_unlock(&(this->mutex));
                return JOB_REQUEUE_NONE;
        }
@@ -950,7 +950,7 @@ static job_requeue_t retransmit(retransmit_data_t *data)
                goto retransmit_end;
        }
        
-       if (++pair->retransmitted >= P2P_MAX_RETRANS)
+       if (++pair->retransmitted >= ME_MAX_RETRANS)
        {
                DBG2(DBG_IKE, "pair with id '%d' failed after %d tries",
                                data->mid, pair->retransmitted);
@@ -960,7 +960,7 @@ static job_requeue_t retransmit(retransmit_data_t *data)
        
        charon->sender->send(charon->sender, pair->packet->clone(pair->packet));
        
-       queue_retransmission(this, checklist->session_id, pair->id);
+       queue_retransmission(this, checklist->connect_id, pair->id);
 
 retransmit_end:
        update_checklist_state(checklist);
@@ -984,11 +984,11 @@ retransmit_end:
 /**
  * Queues a retransmission job
  */
-static void queue_retransmission(private_connect_manager_t *this, chunk_t session_id, u_int32_t mid)
+static void queue_retransmission(private_connect_manager_t *this, chunk_t connect_id, u_int32_t mid)
 {
-       retransmit_data_t *data = retransmit_data_create(this, chunk_clone(session_id), mid);
+       retransmit_data_t *data = retransmit_data_create(this, chunk_clone(connect_id), mid);
        job_t *job = (job_t*)callback_job_create((callback_job_cb_t)retransmit, data, (callback_job_cleanup_t)retransmit_data_destroy, NULL);
-       charon->scheduler->schedule_job(charon->scheduler, (job_t*)job, P2P_RTO_MIN);
+       charon->scheduler->schedule_job(charon->scheduler, (job_t*)job, ME_RTO_MIN);
 }
 
 /**
@@ -1006,13 +1006,13 @@ static void send_check(private_connect_manager_t *this, check_list_t *checklist,
        
        message->set_ike_sa_id(message, ike_sa_id_create(0, 0, request));
 
-       message->add_notify(message, FALSE, P2P_SESSIONID, check->session_id);
-       DBG2(DBG_IKE, "send P2P_SESSIONID %#B", &check->session_id);
+       message->add_notify(message, FALSE, ME_CONNECTID, check->connect_id);
+       DBG2(DBG_IKE, "send ME_CONNECTID %#B", &check->connect_id);
        
        notify_payload_t *endpoint = check->endpoint->build_notify(check->endpoint);
        check->endpoint_raw = chunk_clone(endpoint->get_notification_data(endpoint));
        message->add_payload(message, (payload_t*)endpoint);
-       DBG2(DBG_IKE, "send P2P_ENDPOINT notify");
+       DBG2(DBG_IKE, "send ME_ENDPOINT notify");
        
        check->cookie = build_signature(this, checklist, check, TRUE);
        message->add_notify(message, FALSE, COOKIE, check->cookie);
@@ -1027,7 +1027,7 @@ static void send_check(private_connect_manager_t *this, check_list_t *checklist,
                {
                        DESTROY_IF(pair->packet);
                        pair->packet = packet;
-                       queue_retransmission(this, checklist->session_id, pair->id);
+                       queue_retransmission(this, checklist->connect_id, pair->id);
                }
                else
                {
@@ -1055,10 +1055,10 @@ static job_requeue_t sender(sender_data_t *data)
        pthread_mutex_lock(&(this->mutex));
 
        check_list_t *checklist;
-       if (get_checklist_by_id(this, data->session_id, &checklist) != SUCCESS)
+       if (get_checklist_by_id(this, data->connect_id, &checklist) != SUCCESS)
        {
                DBG1(DBG_IKE, "checklist with id '%B' not found, can't send connectivity check",
-                               &data->session_id);
+                               &data->connect_id);
                pthread_mutex_unlock(&(this->mutex));
                return JOB_REQUEUE_NONE;
        }
@@ -1085,7 +1085,7 @@ static job_requeue_t sender(sender_data_t *data)
        check->mid = pair->id;
        check->src = pair->local->clone(pair->local);
        check->dst = pair->remote->clone(pair->remote);
-       check->session_id = chunk_clone(checklist->session_id);
+       check->connect_id = chunk_clone(checklist->connect_id);
        check->endpoint = endpoint_notify_create();
        
        pair->state = CHECK_IN_PROGRESS;
@@ -1096,7 +1096,7 @@ static job_requeue_t sender(sender_data_t *data)
        
        /* schedule this job again */
        u_int32_t N = this->checklists->get_count(this->checklists);
-       schedule_checks(this, checklist, P2P_INTERVAL * N);
+       schedule_checks(this, checklist, ME_INTERVAL * N);
        
        pthread_mutex_unlock(&(this->mutex));
        
@@ -1109,8 +1109,8 @@ static job_requeue_t sender(sender_data_t *data)
  */
 static void schedule_checks(private_connect_manager_t *this, check_list_t *checklist, u_int32_t time)
 {
-       chunk_t session_id = chunk_clone(checklist->session_id);
-       sender_data_t *data = sender_data_create(this, session_id);
+       chunk_t connect_id = chunk_clone(checklist->connect_id);
+       sender_data_t *data = sender_data_create(this, connect_id);
        job_t *job = (job_t*)callback_job_create((callback_job_cb_t)sender, data, (callback_job_cleanup_t)sender_data_destroy, NULL);
        charon->scheduler->schedule_job(charon->scheduler, job, time);
 }
@@ -1251,7 +1251,7 @@ static void process_request(private_connect_manager_t *this, check_t *check,
                {
                        case CHECK_IN_PROGRESS:
                                /* prevent retransmissions */
-                               pair->retransmitted = P2P_MAX_RETRANS; 
+                               pair->retransmitted = ME_MAX_RETRANS; 
                                /* FIXME: we should wait to the next rto to send the triggered check
                                 * fall-through */
                        case CHECK_WAITING:
@@ -1286,7 +1286,7 @@ static void process_request(private_connect_manager_t *this, check_t *check,
        response->mid = check->mid;
        response->src = check->dst->clone(check->dst);
        response->dst = check->src->clone(check->src);
-       response->session_id = chunk_clone(check->session_id);
+       response->connect_id = chunk_clone(check->connect_id);
        response->endpoint = peer_reflexive;
        
        send_check(this, checklist, response, pair, FALSE);
@@ -1324,10 +1324,10 @@ static void process_check(private_connect_manager_t *this, message_t *message)
        pthread_mutex_lock(&(this->mutex));
        
        check_list_t *checklist;
-       if (get_checklist_by_id(this, check->session_id, &checklist) != SUCCESS)
+       if (get_checklist_by_id(this, check->connect_id, &checklist) != SUCCESS)
        {
                DBG1(DBG_IKE, "checklist with id '%B' not found",
-                               &check->session_id);
+                               &check->connect_id);
                check_destroy(check);
                pthread_mutex_unlock(&(this->mutex));
                return;
@@ -1427,21 +1427,21 @@ static void check_and_initiate(private_connect_manager_t *this, ike_sa_id_t *med
  */
 static status_t set_initiator_data(private_connect_manager_t *this,
                identification_t *initiator, identification_t *responder,
-               chunk_t session_id, chunk_t key, linked_list_t *endpoints, bool is_initiator)
+               chunk_t connect_id, chunk_t key, linked_list_t *endpoints, bool is_initiator)
 {
        check_list_t *checklist;
        
        pthread_mutex_lock(&(this->mutex));     
        
-       if (get_checklist_by_id(this, session_id, NULL) == SUCCESS)
+       if (get_checklist_by_id(this, connect_id, NULL) == SUCCESS)
        {
                DBG1(DBG_IKE, "checklist with id '%B' already exists, aborting",
-                               &session_id);
+                               &connect_id);
                pthread_mutex_unlock(&(this->mutex));
                return FAILED;
        }
        
-       checklist = check_list_create(initiator, responder, session_id, key, endpoints, is_initiator);
+       checklist = check_list_create(initiator, responder, connect_id, key, endpoints, is_initiator);
        this->checklists->insert_last(this->checklists, checklist);
        
        pthread_mutex_unlock(&(this->mutex));
@@ -1453,16 +1453,16 @@ static status_t set_initiator_data(private_connect_manager_t *this,
  * Implementation of connect_manager_t.set_responder_data.
  */
 static status_t set_responder_data(private_connect_manager_t *this,
-               chunk_t session_id, chunk_t key, linked_list_t *endpoints)
+               chunk_t connect_id, chunk_t key, linked_list_t *endpoints)
 {
        check_list_t *checklist;
 
        pthread_mutex_lock(&(this->mutex));
        
-       if (get_checklist_by_id(this, session_id, &checklist) != SUCCESS)
+       if (get_checklist_by_id(this, connect_id, &checklist) != SUCCESS)
        {
                DBG1(DBG_IKE, "checklist with id '%B' not found",
-                               &session_id);
+                               &connect_id);
                pthread_mutex_unlock(&(this->mutex));
                return NOT_FOUND;
        }
index c1a4435..2f121c1 100644 (file)
@@ -67,7 +67,7 @@ struct connect_manager_t {
         * 
         * @param initiator                     ID of the initiator
         * @param responder                     ID of the responder
-        * @param session_id            the session ID provided by the initiator
+        * @param connect_id            the connect ID provided by the initiator
         * @param key                           the initiator's key
         * @param endpoints                     the initiator's endpoints
         * @param is_initiator          TRUE, if the caller of this method is the initiator
@@ -76,13 +76,13 @@ struct connect_manager_t {
         */
        status_t (*set_initiator_data) (connect_manager_t *this,
                identification_t *initiator, identification_t *responder,
-               chunk_t session_id, chunk_t key, linked_list_t *endpoints, bool is_initiator);
+               chunk_t connect_id, chunk_t key, linked_list_t *endpoints, bool is_initiator);
        
        /**
         * Updates a checklist and sets the responder's data. The checklist's
         * state is advanced to WAITING which means that checks will be sent.
         * 
-        * @param session_id            the session ID
+        * @param connect_id            the connect ID
         * @param chunk_t                       the responder's key
         * @param endpoints                     the responder's endpoints 
         * @returns                             
@@ -90,7 +90,7 @@ struct connect_manager_t {
         *                                                      - SUCCESS, otherwise
         */
        status_t (*set_responder_data) (connect_manager_t *this,
-               chunk_t session_id, chunk_t key, linked_list_t *endpoints);
+               chunk_t connect_id, chunk_t key, linked_list_t *endpoints);
        
        
        /**
index 33537bc..da5f0e0 100644 (file)
@@ -63,8 +63,8 @@
 #include <processing/jobs/send_keepalive_job.h>
 #include <processing/jobs/rekey_ike_sa_job.h>
 
-#ifdef P2P
-#include <sa/tasks/ike_p2p.h>
+#ifdef ME
+#include <sa/tasks/ike_me.h>
 #include <processing/jobs/initiate_mediation_job.h>
 #endif
 
@@ -142,12 +142,12 @@ struct private_ike_sa_t {
         */
        host_t *other_host;
        
-#ifdef P2P     
+#ifdef ME
        /**
         * Server reflexive host
         */
        host_t *server_reflexive_host;
-#endif /* P2P */
+#endif /* ME */
                
        /**
         * Identification used for us
@@ -924,7 +924,7 @@ static void send_notify_response(private_ike_sa_t *this, message_t *request,
        response->destroy(response);
 }
 
-#ifdef P2P
+#ifdef ME
 /**
  * Implementation of ike_sa_t.get_server_reflexive_host.
  */
@@ -946,10 +946,10 @@ static void set_server_reflexive_host(private_ike_sa_t *this, host_t *host)
  * Implementation of ike_sa_t.respond
  */
 static status_t respond(private_ike_sa_t *this, identification_t *peer_id,
-               chunk_t session_id)
+               chunk_t connect_id)
 {
-       ike_p2p_t *task = ike_p2p_create(&this->public, TRUE);
-       task->respond(task, peer_id, session_id);
+       ike_me_t *task = ike_me_create(&this->public, TRUE);
+       task->respond(task, peer_id, connect_id);
        this->task_manager->queue_task(this->task_manager, (task_t*)task);
        return this->task_manager->initiate(this->task_manager);
 }
@@ -959,7 +959,7 @@ static status_t respond(private_ike_sa_t *this, identification_t *peer_id,
  */
 static status_t callback(private_ike_sa_t *this, identification_t *peer_id)
 {
-       ike_p2p_t *task = ike_p2p_create(&this->public, TRUE);
+       ike_me_t *task = ike_me_create(&this->public, TRUE);
        task->callback(task, peer_id);
        this->task_manager->queue_task(this->task_manager, (task_t*)task);
        return this->task_manager->initiate(this->task_manager);
@@ -969,10 +969,10 @@ static status_t callback(private_ike_sa_t *this, identification_t *peer_id)
  * Implementation of ike_sa_t.relay
  */
 static status_t relay(private_ike_sa_t *this, identification_t *requester,
-                       chunk_t session_id, chunk_t session_key, linked_list_t *endpoints, bool response)
+                       chunk_t connect_id, chunk_t connect_key, linked_list_t *endpoints, bool response)
 {
-       ike_p2p_t *task = ike_p2p_create(&this->public, TRUE);
-       task->relay(task, requester, session_id, session_key, endpoints, response);
+       ike_me_t *task = ike_me_create(&this->public, TRUE);
+       task->relay(task, requester, connect_id, connect_key, endpoints, response);
        this->task_manager->queue_task(this->task_manager, (task_t*)task);
        return this->task_manager->initiate(this->task_manager);
 }
@@ -982,7 +982,7 @@ static status_t relay(private_ike_sa_t *this, identification_t *requester,
  */
 static status_t initiate_mediation(private_ike_sa_t *this, peer_cfg_t *mediated_cfg)
 {
-       ike_p2p_t *task = ike_p2p_create(&this->public, TRUE);
+       ike_me_t *task = ike_me_create(&this->public, TRUE);
        task->connect(task, mediated_cfg->get_peer_id(mediated_cfg));
        this->task_manager->queue_task(this->task_manager, (task_t*)task);
        return this->task_manager->initiate(this->task_manager);
@@ -1008,7 +1008,7 @@ static status_t initiate_mediated(private_ike_sa_t *this, host_t *me, host_t *ot
        iterator->destroy(iterator);
        return this->task_manager->initiate(this->task_manager);
 }
-#endif /* P2P */
+#endif /* ME */
 
 /**
  * Implementation of ike_sa_t.initiate.
@@ -1020,9 +1020,9 @@ static status_t initiate(private_ike_sa_t *this, child_cfg_t *child_cfg)
        if (this->state == IKE_CREATED)
        {
                if (this->other_host->is_anyaddr(this->other_host)
-#ifdef P2P
+#ifdef ME
                        && !this->peer_cfg->get_mediated_by(this->peer_cfg)
-#endif /* P2P */
+#endif /* ME */
                        )
                {
                        child_cfg->destroy(child_cfg);
@@ -1052,13 +1052,13 @@ static status_t initiate(private_ike_sa_t *this, child_cfg_t *child_cfg)
                        task = (task_t*)ike_mobike_create(&this->public, TRUE);
                        this->task_manager->queue_task(this->task_manager, task);
                }
-#ifdef P2P
-               task = (task_t*)ike_p2p_create(&this->public, TRUE);
+#ifdef ME
+               task = (task_t*)ike_me_create(&this->public, TRUE);
                this->task_manager->queue_task(this->task_manager, task);
-#endif /* P2P */
+#endif /* ME */
        }
 
-#ifdef P2P
+#ifdef ME
        if (this->peer_cfg->get_mediated_by(this->peer_cfg))
        {
                /* mediated connection, initiate mediation process */
@@ -1075,7 +1075,7 @@ static status_t initiate(private_ike_sa_t *this, child_cfg_t *child_cfg)
                }
        }
        else
-#endif /* P2P */
+#endif /* ME */
        {
                /* normal IKE_SA with CHILD_SA */
                task = (task_t*)child_create_create(&this->public, child_cfg);
@@ -1090,7 +1090,7 @@ static status_t initiate(private_ike_sa_t *this, child_cfg_t *child_cfg)
  * Implementation of ike_sa_t.acquire.
  */
 static status_t acquire(private_ike_sa_t *this, u_int32_t reqid)
-{      /* FIXME: P2P-NAT-T */
+{      /* FIXME: IKE-ME */
        child_cfg_t *child_cfg;
        iterator_t *iterator;
        child_sa_t *current, *child_sa = NULL;
@@ -1418,7 +1418,7 @@ static status_t process_message(private_ike_sa_t *this, message_t *message)
  * Implementation of ike_sa_t.retransmit.
  */
 static status_t retransmit(private_ike_sa_t *this, u_int32_t message_id)
-{      /* FIXME: P2P-NAT-T */
+{      /* FIXME: IKE-ME */
        this->time.outbound = time(NULL);
        if (this->task_manager->retransmit(this->task_manager, message_id) != SUCCESS)
        {
@@ -2306,7 +2306,7 @@ static void destroy(private_ike_sa_t *this)
                                                                                                        offsetof(host_t, destroy));
        this->additional_addresses->destroy_offset(this->additional_addresses,
                                                                                                        offsetof(host_t, destroy));
-#ifdef P2P     
+#ifdef ME
        if (this->peer_cfg && this->peer_cfg->is_mediation(this->peer_cfg) &&
                        !this->ike_sa_id->is_initiator(this->ike_sa_id))
        {
@@ -2314,7 +2314,7 @@ static void destroy(private_ike_sa_t *this)
                charon->mediation_manager->remove(charon->mediation_manager, this->ike_sa_id);
        }
        DESTROY_IF(this->server_reflexive_host);
-#endif /* P2P */
+#endif /* ME */
        
        DESTROY_IF(this->my_host);
        DESTROY_IF(this->other_host);
@@ -2400,7 +2400,7 @@ ike_sa_t * ike_sa_create(ike_sa_id_t *ike_sa_id)
        this->public.set_virtual_ip = (void (*)(ike_sa_t*,bool,host_t*))set_virtual_ip;
        this->public.get_virtual_ip = (host_t* (*)(ike_sa_t*,bool))get_virtual_ip;
        this->public.add_dns_server = (void (*)(ike_sa_t*,host_t*))add_dns_server;
-#ifdef P2P
+#ifdef ME
        this->public.get_server_reflexive_host = (host_t* (*)(ike_sa_t*)) get_server_reflexive_host;
        this->public.set_server_reflexive_host = (void (*)(ike_sa_t*,host_t*)) set_server_reflexive_host;
        this->public.initiate_mediation = (status_t (*)(ike_sa_t*,peer_cfg_t*)) initiate_mediation;
@@ -2408,7 +2408,7 @@ ike_sa_t * ike_sa_create(ike_sa_id_t *ike_sa_id)
        this->public.relay = (status_t (*)(ike_sa_t*,identification_t*,chunk_t,chunk_t,linked_list_t*,bool)) relay;
        this->public.callback = (status_t (*)(ike_sa_t*,identification_t*)) callback;
        this->public.respond = (status_t (*)(ike_sa_t*,identification_t*,chunk_t)) respond;
-#endif /* P2P */
+#endif /* ME */
        
        /* initialize private fields */
        this->ike_sa_id = ike_sa_id->clone(ike_sa_id);
@@ -2446,9 +2446,9 @@ ike_sa_t * ike_sa_create(ike_sa_id_t *ike_sa_id)
        this->pending_updates = 0;
        this->keyingtry = 0;
        this->ike_initiator = FALSE;
-#ifdef P2P
+#ifdef ME
        this->server_reflexive_host = NULL;
-#endif /* P2P */
+#endif /* ME */
        
        return &this->public;
 }
index f3d96f9..33b9907 100644 (file)
@@ -434,7 +434,7 @@ struct ike_sa_t {
         */
        void (*set_pending_updates)(ike_sa_t *this, u_int32_t updates);
 
-#ifdef P2P
+#ifdef ME
        /**
         * Get the server reflexive host.
         * 
@@ -451,7 +451,7 @@ struct ike_sa_t {
        
        /**
         * Initiate the mediation of a mediated connection (i.e. initiate a
-        * P2P_CONNECT exchange).
+        * ME_CONNECT exchange).
         * 
         * @param mediated_cfg          peer_cfg of the mediated connection
         * @return                              
@@ -475,21 +475,21 @@ struct ike_sa_t {
        
        /**
         * Relay data from one peer to another (i.e. initiate a
-        * P2P_CONNECT exchange).
+        * ME_CONNECT exchange).
         *
         * Data is cloned.
         * 
         * @param requester                     ID of the requesting peer
-        * @param session_id            data of the P2P_SESSIONID payload
-        * @param session_key           data of the P2P_SESSIONKEY payload
+        * @param connect_id            data of the ME_CONNECTID payload
+        * @param connect_key           data of the ME_CONNECTKEY payload
         * @param endpoints                     endpoints
         * @param response                      TRUE if this is a response
         * @return                              
         *                                                      - SUCCESS if relay started
         *                                                      - DESTROY_ME if relay failed
         */
-       status_t (*relay) (ike_sa_t *this, identification_t *requester, chunk_t session_id,
-                       chunk_t session_key, linked_list_t *endpoints, bool response);
+       status_t (*relay) (ike_sa_t *this, identification_t *requester, chunk_t connect_id,
+                       chunk_t connect_key, linked_list_t *endpoints, bool response);
        
        /**
         * Send a callback to a peer.
@@ -504,18 +504,18 @@ struct ike_sa_t {
        status_t (*callback) (ike_sa_t *this, identification_t *peer_id);
        
        /**
-        * Respond to a P2P_CONNECT request.
+        * Respond to a ME_CONNECT request.
         * 
         * Data is cloned.
         * 
         * @param peer_id                       ID of the other peer
-        * @param session_id            the session ID supplied by the initiator
+        * @param connect_id            the connect ID supplied by the initiator
         * @return
         *                                                      - SUCCESS if response started
         *                                                      - DESTROY_ME if response failed
         */
-       status_t (*respond) (ike_sa_t *this, identification_t *peer_id, chunk_t session_id);
-#endif /* P2P */
+       status_t (*respond) (ike_sa_t *this, identification_t *peer_id, chunk_t connect_id);
+#endif /* ME */
        
        /**
         * Initiate a new connection.
index df06970..b1c755a 100644 (file)
@@ -38,8 +38,8 @@
 #include <encoding/payloads/delete_payload.h>
 #include <processing/jobs/retransmit_job.h>
 
-#ifdef P2P
-#include <sa/tasks/ike_p2p.h>
+#ifdef ME
+#include <sa/tasks/ike_me.h>
 #endif
 
 typedef struct exchange_t exchange_t;
@@ -325,13 +325,13 @@ static status_t build_request(private_task_manager_t *this)
                                        exchange = IKE_SA_INIT;
                                        activate_task(this, IKE_NATD);
                                        activate_task(this, IKE_CERT_PRE);
-#ifdef P2P
+#ifdef ME
                                        /* this task has to be activated before the IKE_AUTHENTICATE
                                         * task, because that task pregenerates the packet after
                                         * which no payloads can be added to the message anymore.
                                         */
-                                       activate_task(this, IKE_P2P);
-#endif /* P2P */
+                                       activate_task(this, IKE_ME);
+#endif /* ME */
                                        activate_task(this, IKE_AUTHENTICATE);
                                        activate_task(this, IKE_CERT_POST);
                                        activate_task(this, IKE_CONFIG);
@@ -381,13 +381,13 @@ static status_t build_request(private_task_manager_t *this)
                                        exchange = INFORMATIONAL;
                                        break;
                                }
-#ifdef P2P
-                               if (activate_task(this, IKE_P2P))
+#ifdef ME
+                               if (activate_task(this, IKE_ME))
                                {
-                                       exchange = P2P_CONNECT;
+                                       exchange = ME_CONNECT;
                                        break;
                                }
-#endif /* P2P */
+#endif /* ME */
                        case IKE_REKEYING:
                                if (activate_task(this, IKE_DELETE))
                                {
@@ -686,10 +686,10 @@ static status_t process_request(private_task_manager_t *this,
                        this->passive_tasks->insert_last(this->passive_tasks, task);
                        task = (task_t*)ike_cert_pre_create(this->ike_sa, FALSE);
                        this->passive_tasks->insert_last(this->passive_tasks, task);
-#ifdef P2P                     
-                       task = (task_t*)ike_p2p_create(this->ike_sa, FALSE);
+#ifdef ME                      
+                       task = (task_t*)ike_me_create(this->ike_sa, FALSE);
                        this->passive_tasks->insert_last(this->passive_tasks, task);
-#endif /* P2P */
+#endif /* ME */
                        task = (task_t*)ike_auth_create(this->ike_sa, FALSE);
                        this->passive_tasks->insert_last(this->passive_tasks, task);
                        task = (task_t*)ike_cert_post_create(this->ike_sa, FALSE);
@@ -817,13 +817,13 @@ static status_t process_request(private_task_manager_t *this,
                        this->passive_tasks->insert_last(this->passive_tasks, task);
                        break;
                }
-#ifdef P2P
-               case P2P_CONNECT:
+#ifdef ME
+               case ME_CONNECT:
                {
-                       task = (task_t*)ike_p2p_create(this->ike_sa, FALSE);
+                       task = (task_t*)ike_me_create(this->ike_sa, FALSE);
                        this->passive_tasks->insert_last(this->passive_tasks, task);
                }
-#endif /* P2P */
+#endif /* ME */
                default:
                        break;
        }
index b96371b..6efd472 100644 (file)
@@ -649,8 +649,8 @@ static status_t process_i(private_ike_auth_t *this, message_t *message)
                                case AUTH_LIFETIME:
                                        /* handled in ike_auth_lifetime task */
                                        break;
-                               case P2P_ENDPOINT:
-                                       /* handled in ike_p2p task */
+                               case ME_ENDPOINT:
+                                       /* handled in ike_me task */
                                        break;
                                default:
                                {
diff --git a/src/charon/sa/tasks/ike_me.c b/src/charon/sa/tasks/ike_me.c
new file mode 100644 (file)
index 0000000..64741c6
--- /dev/null
@@ -0,0 +1,837 @@
+/*
+ * Copyright (C) 2007 Tobias Brunner
+ * Hochschule fuer Technik Rapperswil
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ *
+ * $Id$
+ */
+#include "ike_me.h"
+
+#include <string.h>
+
+#include <daemon.h>
+#include <config/peer_cfg.h>
+#include <encoding/payloads/id_payload.h>
+#include <encoding/payloads/notify_payload.h>
+#include <encoding/payloads/endpoint_notify.h>
+#include <processing/jobs/mediation_job.h>
+
+#define ME_CONNECTID_LEN 8
+#define ME_CONNECTKEY_LEN 16
+
+/* FIXME: proposed values */
+#define ME_CONNECTID_MIN_LEN 4
+#define ME_CONNECTID_MAX_LEN 16
+#define ME_CONNECTKEY_MIN_LEN 8
+#define ME_CONNECTKEY_MAX_LEN 64
+
+
+typedef struct private_ike_me_t private_ike_me_t;
+
+/**
+ * Private members of a ike_me_t task.
+ */
+struct private_ike_me_t {
+       
+       /**
+        * Public methods and task_t interface.
+        */
+       ike_me_t public;
+       
+       /**
+        * Assigned IKE_SA.
+        */
+       ike_sa_t *ike_sa;
+       
+       /**
+        * Are we the initiator?
+        */
+       bool initiator;
+       
+       /**
+        * Is this a mediation connection?
+        */
+       bool mediation;
+       
+       /**
+        * Is this the response from another peer?
+        */
+       bool response;
+       
+       /**
+        * Gathered endpoints
+        */
+       linked_list_t *local_endpoints;
+       
+       /**
+        * Parsed endpoints
+        */
+       linked_list_t *remote_endpoints;
+       
+       /**
+        * Did the peer request a callback?
+        */
+       bool callback;
+       
+       /**
+        * Did the connect fail?
+        */
+       bool failed;
+       
+       /**
+        * Was there anything wrong with the payloads?
+        */
+       bool invalid_syntax;
+       
+       /**
+        * The requested peer
+        */
+       identification_t *peer_id;      
+       /**
+        * Received ID used for connectivity checks
+        */
+       chunk_t connect_id;
+       
+       /**
+        * Received key used for connectivity checks
+        */
+       chunk_t connect_key;
+       
+       /**
+        * Peer config of the mediated connection
+        */
+       peer_cfg_t *mediated_cfg;
+
+};
+
+/**
+ * Adds a list of endpoints as notifies to a given message
+ */
+static void add_endpoints_to_message(message_t *message, linked_list_t *endpoints)
+{
+       iterator_t *iterator;
+       endpoint_notify_t *endpoint;
+       
+       iterator = endpoints->create_iterator(endpoints, TRUE);
+       while (iterator->iterate(iterator, (void**)&endpoint))
+       {
+               message->add_payload(message, (payload_t*)endpoint->build_notify(endpoint));
+       }
+       iterator->destroy(iterator);
+}
+
+/**
+ * Gathers endpoints and adds them to the current message
+ */
+static void gather_and_add_endpoints(private_ike_me_t *this, message_t *message)
+{
+       iterator_t *iterator;
+       host_t *addr, *host;
+       u_int16_t port;
+       
+       /* get the port that is used to communicate with the ms */
+       host = this->ike_sa->get_my_host(this->ike_sa);
+       port = host->get_port(host);
+       
+       iterator = charon->kernel_interface->create_address_iterator(
+                                                                                               charon->kernel_interface);
+       while (iterator->iterate(iterator, (void**)&addr))
+       {
+               host = addr->clone(addr);
+               host->set_port(host, port);
+               
+               this->local_endpoints->insert_last(this->local_endpoints,
+                               endpoint_notify_create_from_host(HOST, host, NULL));
+               
+               host->destroy(host);
+       }
+       iterator->destroy(iterator);
+       
+       host = this->ike_sa->get_server_reflexive_host(this->ike_sa);
+       if (host)
+       {
+               this->local_endpoints->insert_last(this->local_endpoints,
+                               endpoint_notify_create_from_host(SERVER_REFLEXIVE, host,
+                                               this->ike_sa->get_my_host(this->ike_sa)));
+       }
+       
+       add_endpoints_to_message(message, this->local_endpoints);
+}
+
+/**
+ * read notifys from message and evaluate them
+ */
+static void process_payloads(private_ike_me_t *this, message_t *message)
+{
+       iterator_t *iterator;
+       payload_t *payload;
+
+       iterator = message->get_payload_iterator(message);
+       while (iterator->iterate(iterator, (void**)&payload))
+       {
+               if (payload->get_type(payload) != NOTIFY)
+               {
+                       continue;
+               }
+               
+               notify_payload_t *notify = (notify_payload_t*)payload;
+               
+               switch (notify->get_notify_type(notify))
+               {
+                       case ME_CONNECT_FAILED:
+                       {
+                               DBG2(DBG_IKE, "received ME_CONNECT_FAILED notify");
+                               this->failed = TRUE;
+                               break;
+                       }
+                       case ME_MEDIATION:
+                       {
+                               DBG2(DBG_IKE, "received ME_MEDIATION notify");
+                               this->mediation = TRUE;
+                               break;
+                       }
+                       case ME_ENDPOINT:
+                       {
+                               endpoint_notify_t *endpoint = endpoint_notify_create_from_payload(notify);
+                               if (!endpoint)
+                               {
+                                       DBG1(DBG_IKE, "received invalid ME_ENDPOINT notify");
+                                       break;
+                               }
+                               DBG1(DBG_IKE, "received %N ME_ENDPOINT %#H", me_endpoint_type_names,
+                                       endpoint->get_type(endpoint), endpoint->get_host(endpoint));
+                               
+                               this->remote_endpoints->insert_last(this->remote_endpoints, endpoint);
+                               break;
+                       }
+                       case ME_CALLBACK:
+                       {
+                               DBG2(DBG_IKE, "received ME_CALLBACK notify");
+                               this->callback = TRUE;
+                               break;
+                       }
+                       case ME_CONNECTID:
+                       {
+                               chunk_free(&this->connect_id);
+                               this->connect_id = chunk_clone(notify->get_notification_data(notify));
+                               DBG2(DBG_IKE, "received ME_CONNECTID %#B", &this->connect_id);
+                               break;
+                       }
+                       case ME_CONNECTKEY:
+                       {
+                               chunk_free(&this->connect_key);
+                               this->connect_key = chunk_clone(notify->get_notification_data(notify));
+                               DBG4(DBG_IKE, "received ME_CONNECTKEY %#B", &this->connect_key);
+                               break;
+                       }
+                       case ME_RESPONSE:
+                       {
+                               DBG2(DBG_IKE, "received ME_RESPONSE notify");
+                               this->response = TRUE;
+                               break;
+                       }
+                       default:
+                               break;
+               }
+       }
+       iterator->destroy(iterator);
+}
+
+/**
+ * Implementation of task_t.process for initiator
+ */
+static status_t build_i(private_ike_me_t *this, message_t *message)
+{
+       switch(message->get_exchange_type(message))
+       {
+               case IKE_SA_INIT:
+               {
+                       peer_cfg_t *peer_cfg = this->ike_sa->get_peer_cfg(this->ike_sa);
+                       if (peer_cfg->is_mediation(peer_cfg))
+                       {
+                               DBG2(DBG_IKE, "adding ME_MEDIATION");
+                               message->add_notify(message, FALSE, ME_MEDIATION, chunk_empty);
+                       }
+                       else
+                       {
+                               return SUCCESS;
+                       }
+                       break;
+               }
+               case IKE_AUTH:
+               {
+                       if (this->ike_sa->has_condition(this->ike_sa, COND_NAT_HERE))
+                       {
+                               endpoint_notify_t *endpoint = endpoint_notify_create_from_host(SERVER_REFLEXIVE, NULL, NULL);
+                               message->add_payload(message, (payload_t*)endpoint->build_notify(endpoint));
+                               endpoint->destroy(endpoint);
+                       }
+                       break;
+               }
+               case ME_CONNECT:
+               {
+                       id_payload_t *id_payload;
+                       randomizer_t *rand = randomizer_create();
+                       
+                       id_payload = id_payload_create_from_identification(ID_PEER, this->peer_id);
+                       message->add_payload(message, (payload_t*)id_payload);
+                       
+                       if (!this->response)
+                       {
+                               /* only the initiator creates a connect ID. the responder returns
+                                * the connect ID that it received from the initiator */
+                               if (rand->allocate_pseudo_random_bytes(rand,
+                                               ME_CONNECTID_LEN, &this->connect_id) != SUCCESS)
+                               {
+                                       DBG1(DBG_IKE, "unable to generate connect ID for ME_CONNECT");          
+                                       rand->destroy(rand);
+                                       return FAILED;
+                               }
+                       }
+                       
+                       if (rand->allocate_pseudo_random_bytes(rand,
+                                       ME_CONNECTKEY_LEN, &this->connect_key) != SUCCESS)
+                       {
+                               DBG1(DBG_IKE, "unable to generate connect key for ME_CONNECT");
+                               rand->destroy(rand);
+                               return FAILED;
+                       }
+                       
+                       rand->destroy(rand);
+                       
+                       message->add_notify(message, FALSE, ME_CONNECTID, this->connect_id);
+                       message->add_notify(message, FALSE, ME_CONNECTKEY, this->connect_key);
+                       
+                       if (this->response)
+                       {
+                               message->add_notify(message, FALSE, ME_RESPONSE, chunk_empty);
+                       }
+                       else
+                       {
+                               /* FIXME: should we make that configurable? */
+                               message->add_notify(message, FALSE, ME_CALLBACK, chunk_empty);
+                       }
+                       
+                       gather_and_add_endpoints(this, message);
+                       
+                       break;
+               }
+               default:
+                       break;
+       }
+       return NEED_MORE;
+}
+
+/**
+ * Implementation of task_t.process for responder
+ */
+static status_t process_r(private_ike_me_t *this, message_t *message)
+{
+       switch(message->get_exchange_type(message))
+       {
+               case ME_CONNECT:
+               {
+                       id_payload_t *id_payload;
+                       id_payload = (id_payload_t*)message->get_payload(message, ID_PEER);
+                       if (!id_payload)
+                       {
+                               DBG1(DBG_IKE, "received ME_CONNECT without ID_PEER payload, aborting");
+                               break;
+                       }
+                       this->peer_id = id_payload->get_identification(id_payload);
+                       
+                       process_payloads(this, message);
+                       
+                       if (this->callback)
+                       {
+                               DBG1(DBG_IKE, "received ME_CALLBACK for '%D'", this->peer_id);
+                               break;
+                       }                       
+                       
+                       if (!this->connect_id.ptr)
+                       {
+                               DBG1(DBG_IKE, "received ME_CONNECT without ME_CONNECTID notify, aborting");
+                               this->invalid_syntax = TRUE;
+                               break;
+                       }
+                       
+                       if (!this->connect_key.ptr)
+                       {
+                               DBG1(DBG_IKE, "received ME_CONNECT without ME_CONNECTKEY notify, aborting");
+                               this->invalid_syntax = TRUE;
+                               break;
+                       }
+                       
+                       if (!this->remote_endpoints->get_count(this->remote_endpoints))
+                       {
+                               DBG1(DBG_IKE, "received ME_CONNECT without any ME_ENDPOINT payloads, aborting");
+                               this->invalid_syntax = TRUE;
+                               break;
+                       }
+                       
+                       DBG1(DBG_IKE, "received ME_CONNECT");
+                       break;
+               }
+               default:
+                       break;
+       }
+       return NEED_MORE;
+}
+
+/**
+ * Implementation of task_t.build for responder
+ */
+static status_t build_r(private_ike_me_t *this, message_t *message)
+{
+       switch(message->get_exchange_type(message))
+       {
+               case ME_CONNECT:
+               {
+                       if (this->invalid_syntax)
+                       {
+                               message->add_notify(message, TRUE, INVALID_SYNTAX, chunk_empty);
+                               break;
+                       }
+                       
+                       if (this->callback)
+                       {
+                               charon->connect_manager->check_and_initiate(charon->connect_manager,
+                                               this->ike_sa->get_id(this->ike_sa),
+                                               this->ike_sa->get_my_id(this->ike_sa), this->peer_id);
+                               return SUCCESS;
+                       }
+                       
+                       if (this->response)
+                       {
+                               /* FIXME: handle result of set_responder_data
+                                * as initiator, upon receiving a response from another peer,
+                                * update the checklist and start sending checks */
+                               charon->connect_manager->set_responder_data(charon->connect_manager,
+                                               this->connect_id, this->connect_key, this->remote_endpoints);
+                       }
+                       else
+                       {
+                               /* FIXME: handle result of set_initiator_data
+                                * as responder, create a checklist with the initiator's data */
+                               charon->connect_manager->set_initiator_data(charon->connect_manager,
+                                               this->peer_id, this->ike_sa->get_my_id(this->ike_sa),
+                                               this->connect_id, this->connect_key, this->remote_endpoints,
+                                               FALSE);
+                               if (this->ike_sa->respond(this->ike_sa, this->peer_id,
+                                               this->connect_id) != SUCCESS)
+                               {
+                                       return FAILED;
+                               }
+                       }
+                       break;
+               }
+               default:
+                       break;
+       }
+       return SUCCESS;
+}
+
+/**
+ * Implementation of task_t.process for initiator
+ */
+static status_t process_i(private_ike_me_t *this, message_t *message)
+{
+       switch(message->get_exchange_type(message))
+       {
+               case IKE_SA_INIT:
+               {
+                       process_payloads(this, message);
+               
+                       if (!this->mediation)
+                       {
+                               DBG1(DBG_IKE, "server did not return a ME_MEDIATION, aborting");
+                               return FAILED;
+                       }
+       
+                       return NEED_MORE;
+               }
+               case IKE_AUTH:
+               {
+                       process_payloads(this, message);
+                       /* FIXME: we should update the server reflexive endpoint somehow,
+                        * if mobike notices a change */
+                       endpoint_notify_t *reflexive;
+                       if (this->remote_endpoints->get_first(this->remote_endpoints, 
+                                                                                       (void**)&reflexive) == SUCCESS &&
+                               reflexive->get_type(reflexive) == SERVER_REFLEXIVE)
+                       {       /* FIXME: should we accept this endpoint even if we did not send 
+                                * a request? */
+                               host_t *endpoint = reflexive->get_host(reflexive);
+                               
+                               this->ike_sa->set_server_reflexive_host(this->ike_sa, endpoint->clone(endpoint));
+                       }
+                       /* FIXME: what if it failed? e.g. AUTH failure */
+                       SIG(CHILD_UP_SUCCESS, "established mediation connection without CHILD_SA successfully");
+                       
+                       break;
+               }
+               case ME_CONNECT:
+               {
+                       process_payloads(this, message);
+                       
+                       if (this->failed)
+                       {
+                               DBG1(DBG_IKE, "peer '%D' is not online", this->peer_id);
+                               /* FIXME: notify the mediated connection (job?)
+                                * FIXME: probably delete the created checklist, at least as 
+                                * responder */
+                       }
+                       else
+                       {
+                               if (this->response)
+                               {
+                                       /* FIXME: handle result of set_responder_data.
+                                        * as responder, we update the checklist and start sending checks */
+                                       charon->connect_manager->set_responder_data(charon->connect_manager,
+                                                       this->connect_id, this->connect_key, this->local_endpoints);
+                               }
+                               else
+                               {
+                                       /* FIXME: handle result of set_initiator_data
+                                        * as initiator, we create a checklist and set the initiator's data */
+                                       charon->connect_manager->set_initiator_data(charon->connect_manager,
+                                               this->ike_sa->get_my_id(this->ike_sa), this->peer_id,
+                                               this->connect_id, this->connect_key, this->local_endpoints,
+                                               TRUE);
+                               }
+                       }
+                       break;
+               }
+               default:
+                       break;
+       }
+       return SUCCESS;
+}
+
+/**
+ * Implementation of task_t.process for initiator (mediation server)
+ */
+static status_t build_i_ms(private_ike_me_t *this, message_t *message)
+{
+       switch(message->get_exchange_type(message))
+       {
+               case ME_CONNECT:
+               {
+                       id_payload_t *id_payload = id_payload_create_from_identification(ID_PEER, this->peer_id);
+                       message->add_payload(message, (payload_t*)id_payload);
+                       
+                       if (this->callback)
+                       {
+                               message->add_notify(message, FALSE, ME_CALLBACK, chunk_empty);
+                       }
+                       else
+                       {
+                               if (this->response)
+                               {
+                                       message->add_notify(message, FALSE, ME_RESPONSE, chunk_empty);
+                               }       
+                               message->add_notify(message, FALSE, ME_CONNECTID, this->connect_id);
+                               message->add_notify(message, FALSE, ME_CONNECTKEY, this->connect_key);
+                               
+                               add_endpoints_to_message(message, this->remote_endpoints);
+                       }
+                       break;
+               }
+               default:
+                       break;
+       }
+       
+       return NEED_MORE;
+}
+
+/**
+ * Implementation of task_t.process for responder (mediation server)
+ */
+static status_t process_r_ms(private_ike_me_t *this, message_t *message)
+{
+       switch(message->get_exchange_type(message))
+       {
+               case IKE_SA_INIT:
+               {
+                       process_payloads(this, message);
+                       return this->mediation ? NEED_MORE : SUCCESS;
+               }
+               case IKE_AUTH:
+               {
+                       process_payloads(this, message);
+                       break;
+               }
+               case ME_CONNECT:
+               {
+                       id_payload_t *id_payload;
+                       id_payload = (id_payload_t*)message->get_payload(message, ID_PEER);
+                       if (!id_payload)
+                       {
+                               DBG1(DBG_IKE, "received ME_CONNECT without ID_PEER payload, aborting");
+                               this->invalid_syntax = TRUE;
+                               break;
+                       }
+                       
+                       this->peer_id = id_payload->get_identification(id_payload);
+                       
+                       process_payloads(this, message);
+                       
+                       if (!this->connect_id.ptr)
+                       {
+                               DBG1(DBG_IKE, "received ME_CONNECT without ME_CONNECTID notify, aborting");
+                               this->invalid_syntax = TRUE;
+                               break;
+                       }
+                       
+                       if (!this->connect_key.ptr)
+                       {
+                               DBG1(DBG_IKE, "received ME_CONNECT without ME_CONNECTKEY notify, aborting");
+                               this->invalid_syntax = TRUE;
+                               break;
+                       }
+                       
+                       if (!this->remote_endpoints->get_count(this->remote_endpoints))
+                       {
+                               DBG1(DBG_IKE, "received ME_CONNECT without any ME_ENDPOINT payloads, aborting");
+                               this->invalid_syntax = TRUE;
+                               break;
+                       }
+                       break;
+               }
+               default:
+                       break;
+       }
+       
+       return NEED_MORE;
+}
+
+/**
+ * Implementation of task_t.build for responder (mediation server)
+ */
+static status_t build_r_ms(private_ike_me_t *this, message_t *message)
+{
+       switch(message->get_exchange_type(message))
+       {
+               case IKE_SA_INIT:
+               {
+                       message->add_notify(message, FALSE, ME_MEDIATION, chunk_empty);
+                       return NEED_MORE;
+               }
+               case IKE_AUTH:
+               {
+                       endpoint_notify_t *endpoint;
+                       if (this->remote_endpoints->get_first(this->remote_endpoints, (void**)&endpoint) == SUCCESS &&
+                                       endpoint->get_type(endpoint) == SERVER_REFLEXIVE)
+                       {
+                               host_t *host = this->ike_sa->get_other_host(this->ike_sa);
+                               
+                               DBG2(DBG_IKE, "received request for a server reflexive endpoint "
+                                               "sending: %#H", host);
+                               
+                               endpoint = endpoint_notify_create_from_host(SERVER_REFLEXIVE, host, NULL);                                                              
+                               message->add_payload(message, (payload_t*)endpoint->build_notify(endpoint));
+                       }
+                       
+                       charon->mediation_manager->update_sa_id(charon->mediation_manager,
+                                       this->ike_sa->get_other_id(this->ike_sa),
+                                       this->ike_sa->get_id(this->ike_sa));
+                       
+                       SIG(CHILD_UP_SUCCESS, "established mediation connection without CHILD_SA successfully");
+                       
+                       break;
+               }
+               case ME_CONNECT:
+               {       
+                       if (this->invalid_syntax)
+                       {
+                               message->add_notify(message, TRUE, INVALID_SYNTAX, chunk_empty);
+                               break;
+                       }
+                       
+                       ike_sa_id_t *peer_sa;
+                       if (this->callback)
+                       {
+                               peer_sa = charon->mediation_manager->check_and_register(charon->mediation_manager,
+                                               this->peer_id, this->ike_sa->get_other_id(this->ike_sa));
+                       }
+                       else
+                       {
+                               peer_sa = charon->mediation_manager->check(charon->mediation_manager,
+                                               this->peer_id);
+                       }
+                       
+                       if (!peer_sa)
+                       {
+                               /* the peer is not online */
+                               message->add_notify(message, TRUE, ME_CONNECT_FAILED, chunk_empty);
+                               break;
+                       }
+                       
+                       job_t *job = (job_t*)mediation_job_create(this->peer_id,
+                                       this->ike_sa->get_other_id(this->ike_sa), this->connect_id,
+                                       this->connect_key, this->remote_endpoints, this->response);
+                       charon->processor->queue_job(charon->processor, job);
+                       
+                       break;
+               }
+               default:
+                       break;
+       }
+       return SUCCESS;
+}
+
+/**
+ * Implementation of task_t.process for initiator (mediation server)
+ */
+static status_t process_i_ms(private_ike_me_t *this, message_t *message)
+{
+       return SUCCESS;
+}
+
+/**
+ * Implementation of ike_me.connect
+ */
+static void me_connect(private_ike_me_t *this, identification_t *peer_id)
+{
+       this->peer_id = peer_id->clone(peer_id);
+}
+
+/**
+ * Implementation of ike_me.respond
+ */
+static void me_respond(private_ike_me_t *this, identification_t *peer_id, 
+               chunk_t connect_id)
+{
+       this->peer_id = peer_id->clone(peer_id);
+       this->connect_id = chunk_clone(connect_id);
+       this->response = TRUE;
+}
+
+/**
+ * Implementation of ike_me.callback
+ */
+static void me_callback(private_ike_me_t *this, identification_t *peer_id)
+{
+       this->peer_id = peer_id->clone(peer_id);
+       this->callback = TRUE;
+}
+
+/**
+ * Implementation of ike_me.relay
+ */
+static void relay(private_ike_me_t *this, identification_t *requester, chunk_t connect_id,
+               chunk_t connect_key, linked_list_t *endpoints, bool response)
+{
+       this->peer_id = requester->clone(requester);
+       this->connect_id = chunk_clone(connect_id);
+       this->connect_key = chunk_clone(connect_key);
+       this->remote_endpoints = endpoints->clone_offset(endpoints, offsetof(endpoint_notify_t, clone));
+       this->response = response;
+}
+
+/**
+ * Implementation of task_t.get_type
+ */
+static task_type_t get_type(private_ike_me_t *this)
+{
+       return IKE_ME;
+}
+
+/**
+ * Implementation of task_t.migrate
+ */
+static void migrate(private_ike_me_t *this, ike_sa_t *ike_sa)
+{
+       this->ike_sa = ike_sa;
+}
+
+/**
+ * Implementation of task_t.destroy
+ */
+static void destroy(private_ike_me_t *this)
+{
+       DESTROY_IF(this->peer_id);
+       
+       chunk_free(&this->connect_id);
+       chunk_free(&this->connect_key);
+       
+       this->local_endpoints->destroy_offset(this->local_endpoints, offsetof(endpoint_notify_t, destroy));
+       this->remote_endpoints->destroy_offset(this->remote_endpoints, offsetof(endpoint_notify_t, destroy));
+       
+       DESTROY_IF(this->mediated_cfg);
+       free(this);
+}
+
+/*
+ * Described in header.
+ */
+ike_me_t *ike_me_create(ike_sa_t *ike_sa, bool initiator)
+{
+       private_ike_me_t *this = malloc_thing(private_ike_me_t);
+
+       this->public.task.get_type = (task_type_t(*)(task_t*))get_type;
+       this->public.task.migrate = (void(*)(task_t*,ike_sa_t*))migrate;
+       this->public.task.destroy = (void(*)(task_t*))destroy;
+       
+       ike_sa_id_t *id = ike_sa->get_id(ike_sa);
+       if (id->is_initiator(id))
+       {
+               if (initiator)
+               {
+                       this->public.task.build = (status_t(*)(task_t*,message_t*))build_i;
+                       this->public.task.process = (status_t(*)(task_t*,message_t*))process_i;
+               }
+               else
+               {
+                       this->public.task.build = (status_t(*)(task_t*,message_t*))build_r;
+                       this->public.task.process = (status_t(*)(task_t*,message_t*))process_r;
+               }
+       }
+       else
+       {
+               /* mediation server */
+               if (initiator)
+               {
+                       this->public.task.build = (status_t(*)(task_t*,message_t*))build_i_ms;
+                       this->public.task.process = (status_t(*)(task_t*,message_t*))process_i_ms;
+               }
+               else
+               {
+                       this->public.task.build = (status_t(*)(task_t*,message_t*))build_r_ms;
+                       this->public.task.process = (status_t(*)(task_t*,message_t*))process_r_ms;
+               }
+       }
+       
+       this->public.connect = (void(*)(ike_me_t*,identification_t*))me_connect;
+       this->public.respond = (void(*)(ike_me_t*,identification_t*,chunk_t))me_respond;
+       this->public.callback = (void(*)(ike_me_t*,identification_t*))me_callback;
+       this->public.relay = (void(*)(ike_me_t*,identification_t*,chunk_t,chunk_t,linked_list_t*,bool))relay;
+       
+       this->ike_sa = ike_sa;
+       this->initiator = initiator;
+       
+       this->peer_id = NULL;
+       this->connect_id = chunk_empty;
+       this->connect_key = chunk_empty;
+       this->local_endpoints = linked_list_create();
+       this->remote_endpoints = linked_list_create();
+       this->mediation = FALSE;
+       this->response = FALSE;
+       this->callback = FALSE;
+       this->failed = FALSE;
+       this->invalid_syntax = FALSE;
+       
+       this->mediated_cfg = NULL;
+       
+       return &this->public;
+}
diff --git a/src/charon/sa/tasks/ike_me.h b/src/charon/sa/tasks/ike_me.h
new file mode 100644 (file)
index 0000000..7fdc724
--- /dev/null
@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2007 Tobias Brunner
+ * Hochschule fuer Technik Rapperswil
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ *
+ * $Id$
+ */
+
+/**
+ * @defgroup ike_me ike_me
+ * @{ @ingroup tasks
+ */
+
+#ifndef IKE_ME_H_
+#define IKE_ME_H_
+
+typedef struct ike_me_t ike_me_t;
+
+#include <library.h>
+#include <sa/ike_sa.h>
+#include <sa/tasks/task.h>
+
+/**
+ * Task of type IKE_ME, detects and handles IKE-ME extensions.
+ *
+ * This tasks handles the ME_MEDIATION Notify exchange to setup a mediation
+ * connection, allows to initiate mediated connections using ME_CONNECT
+ * exchanges and to request reflexive addresses from the mediation server using
+ * ME_ENDPOINT notifies.
+ * 
+ * @note This task has to be activated before the IKE_AUTH task, because that
+ * task generates the IKE_SA_INIT message so that no more payloads can be added
+ * to it afterwards.
+ */
+struct ike_me_t {
+
+       /**
+        * Implements the task_t interface
+        */
+       task_t task;
+       
+       /**
+        * Initiates a connection with another peer (i.e. sends a ME_CONNECT
+        * to the mediation server)
+        *
+        * @param peer_id                       ID of the other peer (gets cloned)
+        */
+       void (*connect)(ike_me_t *this, identification_t *peer_id);
+       
+       /**
+        * Responds to a ME_CONNECT from another peer (i.e. sends a ME_CONNECT
+        * to the mediation server)
+        * 
+        * @param peer_id                       ID of the other peer (gets cloned)
+        * @param connect_id            the connect ID as provided by the initiator (gets cloned)
+        */
+       void (*respond)(ike_me_t *this, identification_t *peer_id, chunk_t connect_id);
+       
+       /**
+        * Sends a ME_CALLBACK to a peer that previously requested another peer.
+        * 
+        * @param peer_id                       ID of the other peer (gets cloned)
+        */
+       void (*callback)(ike_me_t *this, identification_t *peer_id);
+       
+       /**
+        * Relays data to another peer (i.e. sends a ME_CONNECT to the peer)
+        * 
+        * Data gets cloned.
+        * 
+        * @param requester                     ID of the requesting peer
+        * @param connect_id            content of the ME_CONNECTID notify
+        * @param connect_key           content of the ME_CONNECTKEY notify
+        * @param endpoints                     endpoints
+        * @param response                      TRUE if this is a response
+        */
+       void (*relay)(ike_me_t *this, identification_t *requester, chunk_t connect_id,
+                       chunk_t connect_key, linked_list_t *endpoints, bool response);
+
+};
+
+/**
+ * Create a new ike_me task.
+ *
+ * @param ike_sa               IKE_SA this task works for
+ * @param initiator            TRUE if taks is initiated by us
+ * @return                             ike_me task to handle by the task_manager
+ */
+ike_me_t *ike_me_create(ike_sa_t *ike_sa, bool initiator);
+
+#endif /*IKE_ME_H_ @} */
index 1662a32..e8daecd 100644 (file)
@@ -254,7 +254,7 @@ static status_t process_i(private_ike_natd_t *this, message_t *message)
        {
                peer_cfg_t *peer_cfg = this->ike_sa->get_peer_cfg(this->ike_sa);
 
-#ifdef P2P             
+#ifdef ME
                /* if we are on a mediated connection we have already switched to
                 * port 4500 and the correct destination port is already configured,
                 * therefore we must not switch again */
@@ -262,14 +262,14 @@ static status_t process_i(private_ike_natd_t *this, message_t *message)
                {
                        return SUCCESS;
                }
-#endif /* P2P */
+#endif /* ME */
                
                if (this->ike_sa->has_condition(this->ike_sa, COND_NAT_ANY) ||
-#ifdef P2P
+#ifdef ME
                        /* if we are on a mediation connection we swith to port 4500 even
                         * if no NAT is detected. */
                        peer_cfg->is_mediation(peer_cfg) ||
-#endif /* P2P */
+#endif /* ME */
                        /* if peer supports NAT-T, we switch to port 4500 even
                         * if no NAT is detected. MOBIKE requires this. */
                        (peer_cfg->use_mobike(peer_cfg) &&
diff --git a/src/charon/sa/tasks/ike_p2p.c b/src/charon/sa/tasks/ike_p2p.c
deleted file mode 100644 (file)
index 5a9ae00..0000000
+++ /dev/null
@@ -1,837 +0,0 @@
-/*
- * Copyright (C) 2007 Tobias Brunner
- * Hochschule fuer Technik Rapperswil
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation; either version 2 of the License, or (at your
- * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * for more details.
- *
- * $Id$
- */
-#include "ike_p2p.h"
-
-#include <string.h>
-
-#include <daemon.h>
-#include <config/peer_cfg.h>
-#include <encoding/payloads/id_payload.h>
-#include <encoding/payloads/notify_payload.h>
-#include <encoding/payloads/endpoint_notify.h>
-#include <processing/jobs/mediation_job.h>
-
-#define P2P_SESSIONID_LEN 8
-#define P2P_SESSIONKEY_LEN 16
-
-/* FIXME: proposed values */
-#define P2P_SESSIONID_MIN_LEN 4
-#define P2P_SESSIONID_MAX_LEN 16
-#define P2P_SESSIONKEY_MIN_LEN 8
-#define P2P_SESSIONKEY_MAX_LEN 64
-
-
-typedef struct private_ike_p2p_t private_ike_p2p_t;
-
-/**
- * Private members of a ike_p2p_t task.
- */
-struct private_ike_p2p_t {
-       
-       /**
-        * Public methods and task_t interface.
-        */
-       ike_p2p_t public;
-       
-       /**
-        * Assigned IKE_SA.
-        */
-       ike_sa_t *ike_sa;
-       
-       /**
-        * Are we the initiator?
-        */
-       bool initiator;
-       
-       /**
-        * Is this a mediation connection?
-        */
-       bool mediation;
-       
-       /**
-        * Is this the response from another peer?
-        */
-       bool response;
-       
-       /**
-        * Gathered endpoints
-        */
-       linked_list_t *local_endpoints;
-       
-       /**
-        * Parsed endpoints
-        */
-       linked_list_t *remote_endpoints;
-       
-       /**
-        * Did the peer request a callback?
-        */
-       bool callback;
-       
-       /**
-        * Did the connect fail?
-        */
-       bool failed;
-       
-       /**
-        * Was there anything wrong with the payloads?
-        */
-       bool invalid_syntax;
-       
-       /**
-        * The requested peer
-        */
-       identification_t *peer_id;      
-       /**
-        * Received ID used for connectivity checks
-        */
-       chunk_t session_id;
-       
-       /**
-        * Received key used for connectivity checks
-        */
-       chunk_t session_key;
-       
-       /**
-        * Peer config of the mediated connection
-        */
-       peer_cfg_t *mediated_cfg;
-
-};
-
-/**
- * Adds a list of endpoints as notifies to a given message
- */
-static void add_endpoints_to_message(message_t *message, linked_list_t *endpoints)
-{
-       iterator_t *iterator;
-       endpoint_notify_t *endpoint;
-       
-       iterator = endpoints->create_iterator(endpoints, TRUE);
-       while (iterator->iterate(iterator, (void**)&endpoint))
-       {
-               message->add_payload(message, (payload_t*)endpoint->build_notify(endpoint));
-       }
-       iterator->destroy(iterator);
-}
-
-/**
- * Gathers endpoints and adds them to the current message
- */
-static void gather_and_add_endpoints(private_ike_p2p_t *this, message_t *message)
-{
-       iterator_t *iterator;
-       host_t *addr, *host;
-       u_int16_t port;
-       
-       /* get the port that is used to communicate with the ms */
-       host = this->ike_sa->get_my_host(this->ike_sa);
-       port = host->get_port(host);
-       
-       iterator = charon->kernel_interface->create_address_iterator(
-                                                                                               charon->kernel_interface);
-       while (iterator->iterate(iterator, (void**)&addr))
-       {
-               host = addr->clone(addr);
-               host->set_port(host, port);
-               
-               this->local_endpoints->insert_last(this->local_endpoints,
-                               endpoint_notify_create_from_host(HOST, host, NULL));
-               
-               host->destroy(host);
-       }
-       iterator->destroy(iterator);
-       
-       host = this->ike_sa->get_server_reflexive_host(this->ike_sa);
-       if (host)
-       {
-               this->local_endpoints->insert_last(this->local_endpoints,
-                               endpoint_notify_create_from_host(SERVER_REFLEXIVE, host,
-                                               this->ike_sa->get_my_host(this->ike_sa)));
-       }
-       
-       add_endpoints_to_message(message, this->local_endpoints);
-}
-
-/**
- * read notifys from message and evaluate them
- */
-static void process_payloads(private_ike_p2p_t *this, message_t *message)
-{
-       iterator_t *iterator;
-       payload_t *payload;
-
-       iterator = message->get_payload_iterator(message);
-       while (iterator->iterate(iterator, (void**)&payload))
-       {
-               if (payload->get_type(payload) != NOTIFY)
-               {
-                       continue;
-               }
-               
-               notify_payload_t *notify = (notify_payload_t*)payload;
-               
-               switch (notify->get_notify_type(notify))
-               {
-                       case P2P_CONNECT_FAILED:
-                       {
-                               DBG2(DBG_IKE, "received P2P_CONNECT_FAILED notify");
-                               this->failed = TRUE;
-                               break;
-                       }
-                       case P2P_MEDIATION:
-                       {
-                               DBG2(DBG_IKE, "received P2P_MEDIATION notify");
-                               this->mediation = TRUE;
-                               break;
-                       }
-                       case P2P_ENDPOINT:
-                       {
-                               endpoint_notify_t *endpoint = endpoint_notify_create_from_payload(notify);
-                               if (!endpoint)
-                               {
-                                       DBG1(DBG_IKE, "received invalid P2P_ENDPOINT notify");
-                                       break;
-                               }
-                               DBG1(DBG_IKE, "received %N P2P_ENDPOINT %#H", p2p_endpoint_type_names,
-                                       endpoint->get_type(endpoint), endpoint->get_host(endpoint));
-                               
-                               this->remote_endpoints->insert_last(this->remote_endpoints, endpoint);
-                               break;
-                       }
-                       case P2P_CALLBACK:
-                       {
-                               DBG2(DBG_IKE, "received P2P_CALLBACK notify");
-                               this->callback = TRUE;
-                               break;
-                       }
-                       case P2P_SESSIONID:
-                       {
-                               chunk_free(&this->session_id);
-                               this->session_id = chunk_clone(notify->get_notification_data(notify));
-                               DBG2(DBG_IKE, "received P2P_SESSIONID %#B", &this->session_id);
-                               break;
-                       }
-                       case P2P_SESSIONKEY:
-                       {
-                               chunk_free(&this->session_key);
-                               this->session_key = chunk_clone(notify->get_notification_data(notify));
-                               DBG4(DBG_IKE, "received P2P_SESSIONKEY %#B", &this->session_key);
-                               break;
-                       }
-                       case P2P_RESPONSE:
-                       {
-                               DBG2(DBG_IKE, "received P2P_RESPONSE notify");
-                               this->response = TRUE;
-                               break;
-                       }
-                       default:
-                               break;
-               }
-       }
-       iterator->destroy(iterator);
-}
-
-/**
- * Implementation of task_t.process for initiator
- */
-static status_t build_i(private_ike_p2p_t *this, message_t *message)
-{
-       switch(message->get_exchange_type(message))
-       {
-               case IKE_SA_INIT:
-               {
-                       peer_cfg_t *peer_cfg = this->ike_sa->get_peer_cfg(this->ike_sa);
-                       if (peer_cfg->is_mediation(peer_cfg))
-                       {
-                               DBG2(DBG_IKE, "adding P2P_MEDIATION");
-                               message->add_notify(message, FALSE, P2P_MEDIATION, chunk_empty);
-                       }
-                       else
-                       {
-                               return SUCCESS;
-                       }
-                       break;
-               }
-               case IKE_AUTH:
-               {
-                       if (this->ike_sa->has_condition(this->ike_sa, COND_NAT_HERE))
-                       {
-                               endpoint_notify_t *endpoint = endpoint_notify_create_from_host(SERVER_REFLEXIVE, NULL, NULL);
-                               message->add_payload(message, (payload_t*)endpoint->build_notify(endpoint));
-                               endpoint->destroy(endpoint);
-                       }
-                       break;
-               }
-               case P2P_CONNECT:
-               {
-                       id_payload_t *id_payload;
-                       randomizer_t *rand = randomizer_create();
-                       
-                       id_payload = id_payload_create_from_identification(ID_PEER, this->peer_id);
-                       message->add_payload(message, (payload_t*)id_payload);
-                       
-                       if (!this->response)
-                       {
-                               /* only the initiator creates a session ID. the responder returns
-                                * the session ID that it received from the initiator */
-                               if (rand->allocate_pseudo_random_bytes(rand,
-                                               P2P_SESSIONID_LEN, &this->session_id) != SUCCESS)
-                               {
-                                       DBG1(DBG_IKE, "unable to generate session ID for P2P_CONNECT");         
-                                       rand->destroy(rand);
-                                       return FAILED;
-                               }
-                       }
-                       
-                       if (rand->allocate_pseudo_random_bytes(rand,
-                                       P2P_SESSIONKEY_LEN, &this->session_key) != SUCCESS)
-                       {
-                               DBG1(DBG_IKE, "unable to generate session key for P2P_CONNECT");
-                               rand->destroy(rand);
-                               return FAILED;
-                       }
-                       
-                       rand->destroy(rand);
-                       
-                       message->add_notify(message, FALSE, P2P_SESSIONID, this->session_id);
-                       message->add_notify(message, FALSE, P2P_SESSIONKEY, this->session_key);
-                       
-                       if (this->response)
-                       {
-                               message->add_notify(message, FALSE, P2P_RESPONSE, chunk_empty);
-                       }
-                       else
-                       {
-                               /* FIXME: should we make that configurable? */
-                               message->add_notify(message, FALSE, P2P_CALLBACK, chunk_empty);
-                       }
-                       
-                       gather_and_add_endpoints(this, message);
-                       
-                       break;
-               }
-               default:
-                       break;
-       }
-       return NEED_MORE;
-}
-
-/**
- * Implementation of task_t.process for responder
- */
-static status_t process_r(private_ike_p2p_t *this, message_t *message)
-{
-       switch(message->get_exchange_type(message))
-       {
-               case P2P_CONNECT:
-               {
-                       id_payload_t *id_payload;
-                       id_payload = (id_payload_t*)message->get_payload(message, ID_PEER);
-                       if (!id_payload)
-                       {
-                               DBG1(DBG_IKE, "received P2P_CONNECT without ID_PEER payload, aborting");
-                               break;
-                       }
-                       this->peer_id = id_payload->get_identification(id_payload);
-                       
-                       process_payloads(this, message);
-                       
-                       if (this->callback)
-                       {
-                               DBG1(DBG_IKE, "received P2P_CALLBACK for '%D'", this->peer_id);
-                               break;
-                       }                       
-                       
-                       if (!this->session_id.ptr)
-                       {
-                               DBG1(DBG_IKE, "received P2P_CONNECT without P2P_SESSIONID notify, aborting");
-                               this->invalid_syntax = TRUE;
-                               break;
-                       }
-                       
-                       if (!this->session_key.ptr)
-                       {
-                               DBG1(DBG_IKE, "received P2P_CONNECT without P2P_SESSIONKEY notify, aborting");
-                               this->invalid_syntax = TRUE;
-                               break;
-                       }
-                       
-                       if (!this->remote_endpoints->get_count(this->remote_endpoints))
-                       {
-                               DBG1(DBG_IKE, "received P2P_CONNECT without any P2P_ENDPOINT payloads, aborting");
-                               this->invalid_syntax = TRUE;
-                               break;
-                       }
-                       
-                       DBG1(DBG_IKE, "received P2P_CONNECT");
-                       break;
-               }
-               default:
-                       break;
-       }
-       return NEED_MORE;
-}
-
-/**
- * Implementation of task_t.build for responder
- */
-static status_t build_r(private_ike_p2p_t *this, message_t *message)
-{
-       switch(message->get_exchange_type(message))
-       {
-               case P2P_CONNECT:
-               {
-                       if (this->invalid_syntax)
-                       {
-                               message->add_notify(message, TRUE, INVALID_SYNTAX, chunk_empty);
-                               break;
-                       }
-                       
-                       if (this->callback)
-                       {
-                               charon->connect_manager->check_and_initiate(charon->connect_manager,
-                                               this->ike_sa->get_id(this->ike_sa),
-                                               this->ike_sa->get_my_id(this->ike_sa), this->peer_id);
-                               return SUCCESS;
-                       }
-                       
-                       if (this->response)
-                       {
-                               /* FIXME: handle result of set_responder_data
-                                * as initiator, upon receiving a response from another peer,
-                                * update the checklist and start sending checks */
-                               charon->connect_manager->set_responder_data(charon->connect_manager,
-                                               this->session_id, this->session_key, this->remote_endpoints);
-                       }
-                       else
-                       {
-                               /* FIXME: handle result of set_initiator_data
-                                * as responder, create a checklist with the initiator's data */
-                               charon->connect_manager->set_initiator_data(charon->connect_manager,
-                                               this->peer_id, this->ike_sa->get_my_id(this->ike_sa),
-                                               this->session_id, this->session_key, this->remote_endpoints,
-                                               FALSE);
-                               if (this->ike_sa->respond(this->ike_sa, this->peer_id,
-                                               this->session_id) != SUCCESS)
-                               {
-                                       return FAILED;
-                               }
-                       }
-                       break;
-               }
-               default:
-                       break;
-       }
-       return SUCCESS;
-}
-
-/**
- * Implementation of task_t.process for initiator
- */
-static status_t process_i(private_ike_p2p_t *this, message_t *message)
-{
-       switch(message->get_exchange_type(message))
-       {
-               case IKE_SA_INIT:
-               {
-                       process_payloads(this, message);
-               
-                       if (!this->mediation)
-                       {
-                               DBG1(DBG_IKE, "server did not return a P2P_MEDIATION, aborting");
-                               return FAILED;
-                       }
-       
-                       return NEED_MORE;
-               }
-               case IKE_AUTH:
-               {
-                       process_payloads(this, message);
-                       /* FIXME: we should update the server reflexive endpoint somehow,
-                        * if mobike notices a change */
-                       endpoint_notify_t *reflexive;
-                       if (this->remote_endpoints->get_first(this->remote_endpoints, 
-                                                                                       (void**)&reflexive) == SUCCESS &&
-                               reflexive->get_type(reflexive) == SERVER_REFLEXIVE)
-                       {       /* FIXME: should we accept this endpoint even if we did not send 
-                                * a request? */
-                               host_t *endpoint = reflexive->get_host(reflexive);
-                               
-                               this->ike_sa->set_server_reflexive_host(this->ike_sa, endpoint->clone(endpoint));
-                       }
-                       /* FIXME: what if it failed? e.g. AUTH failure */
-                       SIG(CHILD_UP_SUCCESS, "established mediation connection without CHILD_SA successfully");
-                       
-                       break;
-               }
-               case P2P_CONNECT:
-               {
-                       process_payloads(this, message);
-                       
-                       if (this->failed)
-                       {
-                               DBG1(DBG_IKE, "peer '%D' is not online", this->peer_id);
-                               /* FIXME: notify the mediated connection (job?)
-                                * FIXME: probably delete the created checklist, at least as 
-                                * responder */
-                       }
-                       else
-                       {
-                               if (this->response)
-                               {
-                                       /* FIXME: handle result of set_responder_data.
-                                        * as responder, we update the checklist and start sending checks */
-                                       charon->connect_manager->set_responder_data(charon->connect_manager,
-                                                       this->session_id, this->session_key, this->local_endpoints);
-                               }
-                               else
-                               {
-                                       /* FIXME: handle result of set_initiator_data
-                                        * as initiator, we create a checklist and set the initiator's data */
-                                       charon->connect_manager->set_initiator_data(charon->connect_manager,
-                                               this->ike_sa->get_my_id(this->ike_sa), this->peer_id,
-                                               this->session_id, this->session_key, this->local_endpoints,
-                                               TRUE);
-                               }
-                       }
-                       break;
-               }
-               default:
-                       break;
-       }
-       return SUCCESS;
-}
-
-/**
- * Implementation of task_t.process for initiator (mediation server)
- */
-static status_t build_i_ms(private_ike_p2p_t *this, message_t *message)
-{
-       switch(message->get_exchange_type(message))
-       {
-               case P2P_CONNECT:
-               {
-                       id_payload_t *id_payload = id_payload_create_from_identification(ID_PEER, this->peer_id);
-                       message->add_payload(message, (payload_t*)id_payload);
-                       
-                       if (this->callback)
-                       {
-                               message->add_notify(message, FALSE, P2P_CALLBACK, chunk_empty);
-                       }
-                       else
-                       {
-                               if (this->response)
-                               {
-                                       message->add_notify(message, FALSE, P2P_RESPONSE, chunk_empty);
-                               }       
-                               message->add_notify(message, FALSE, P2P_SESSIONID, this->session_id);
-                               message->add_notify(message, FALSE, P2P_SESSIONKEY, this->session_key);
-                               
-                               add_endpoints_to_message(message, this->remote_endpoints);
-                       }
-                       break;
-               }
-               default:
-                       break;
-       }
-       
-       return NEED_MORE;
-}
-
-/**
- * Implementation of task_t.process for responder (mediation server)
- */
-static status_t process_r_ms(private_ike_p2p_t *this, message_t *message)
-{
-       switch(message->get_exchange_type(message))
-       {
-               case IKE_SA_INIT:
-               {
-                       process_payloads(this, message);
-                       return this->mediation ? NEED_MORE : SUCCESS;
-               }
-               case IKE_AUTH:
-               {
-                       process_payloads(this, message);
-                       break;
-               }
-               case P2P_CONNECT:
-               {
-                       id_payload_t *id_payload;
-                       id_payload = (id_payload_t*)message->get_payload(message, ID_PEER);
-                       if (!id_payload)
-                       {
-                               DBG1(DBG_IKE, "received P2P_CONNECT without ID_PEER payload, aborting");
-                               this->invalid_syntax = TRUE;
-                               break;
-                       }
-                       
-                       this->peer_id = id_payload->get_identification(id_payload);
-                       
-                       process_payloads(this, message);
-                       
-                       if (!this->session_id.ptr)
-                       {
-                               DBG1(DBG_IKE, "received P2P_CONNECT without P2P_SESSIONID notify, aborting");
-                               this->invalid_syntax = TRUE;
-                               break;
-                       }
-                       
-                       if (!this->session_key.ptr)
-                       {
-                               DBG1(DBG_IKE, "received P2P_CONNECT without P2P_SESSIONKEY notify, aborting");
-                               this->invalid_syntax = TRUE;
-                               break;
-                       }
-                       
-                       if (!this->remote_endpoints->get_count(this->remote_endpoints))
-                       {
-                               DBG1(DBG_IKE, "received P2P_CONNECT without any P2P_ENDPOINT payloads, aborting");
-                               this->invalid_syntax = TRUE;
-                               break;
-                       }
-                       break;
-               }
-               default:
-                       break;
-       }
-       
-       return NEED_MORE;
-}
-
-/**
- * Implementation of task_t.build for responder (mediation server)
- */
-static status_t build_r_ms(private_ike_p2p_t *this, message_t *message)
-{
-       switch(message->get_exchange_type(message))
-       {
-               case IKE_SA_INIT:
-               {
-                       message->add_notify(message, FALSE, P2P_MEDIATION, chunk_empty);
-                       return NEED_MORE;
-               }
-               case IKE_AUTH:
-               {
-                       endpoint_notify_t *endpoint;
-                       if (this->remote_endpoints->get_first(this->remote_endpoints, (void**)&endpoint) == SUCCESS &&
-                                       endpoint->get_type(endpoint) == SERVER_REFLEXIVE)
-                       {
-                               host_t *host = this->ike_sa->get_other_host(this->ike_sa);
-                               
-                               DBG2(DBG_IKE, "received request for a server reflexive endpoint "
-                                               "sending: %#H", host);
-                               
-                               endpoint = endpoint_notify_create_from_host(SERVER_REFLEXIVE, host, NULL);                                                              
-                               message->add_payload(message, (payload_t*)endpoint->build_notify(endpoint));
-                       }
-                       
-                       charon->mediation_manager->update_sa_id(charon->mediation_manager,
-                                       this->ike_sa->get_other_id(this->ike_sa),
-                                       this->ike_sa->get_id(this->ike_sa));
-                       
-                       SIG(CHILD_UP_SUCCESS, "established mediation connection without CHILD_SA successfully");
-                       
-                       break;
-               }
-               case P2P_CONNECT:
-               {       
-                       if (this->invalid_syntax)
-                       {
-                               message->add_notify(message, TRUE, INVALID_SYNTAX, chunk_empty);
-                               break;
-                       }
-                       
-                       ike_sa_id_t *peer_sa;
-                       if (this->callback)
-                       {
-                               peer_sa = charon->mediation_manager->check_and_register(charon->mediation_manager,
-                                               this->peer_id, this->ike_sa->get_other_id(this->ike_sa));
-                       }
-                       else
-                       {
-                               peer_sa = charon->mediation_manager->check(charon->mediation_manager,
-                                               this->peer_id);
-                       }
-                       
-                       if (!peer_sa)
-                       {
-                               /* the peer is not online */
-                               message->add_notify(message, TRUE, P2P_CONNECT_FAILED, chunk_empty);
-                               break;
-                       }
-                       
-                       job_t *job = (job_t*)mediation_job_create(this->peer_id,
-                                       this->ike_sa->get_other_id(this->ike_sa), this->session_id,
-                                       this->session_key, this->remote_endpoints, this->response);
-                       charon->processor->queue_job(charon->processor, job);
-                       
-                       break;
-               }
-               default:
-                       break;
-       }
-       return SUCCESS;
-}
-
-/**
- * Implementation of task_t.process for initiator (mediation server)
- */
-static status_t process_i_ms(private_ike_p2p_t *this, message_t *message)
-{
-       return SUCCESS;
-}
-
-/**
- * Implementation of ike_p2p.connect
- */
-static void p2p_connect(private_ike_p2p_t *this, identification_t *peer_id)
-{
-       this->peer_id = peer_id->clone(peer_id);
-}
-
-/**
- * Implementation of ike_p2p.respond
- */
-static void p2p_respond(private_ike_p2p_t *this, identification_t *peer_id, 
-               chunk_t session_id)
-{
-       this->peer_id = peer_id->clone(peer_id);
-       this->session_id = chunk_clone(session_id);
-       this->response = TRUE;
-}
-
-/**
- * Implementation of ike_p2p.callback
- */
-static void p2p_callback(private_ike_p2p_t *this, identification_t *peer_id)
-{
-       this->peer_id = peer_id->clone(peer_id);
-       this->callback = TRUE;
-}
-
-/**
- * Implementation of ike_p2p.relay
- */
-static void relay(private_ike_p2p_t *this, identification_t *requester, chunk_t session_id,
-               chunk_t session_key, linked_list_t *endpoints, bool response)
-{
-       this->peer_id = requester->clone(requester);
-       this->session_id = chunk_clone(session_id);
-       this->session_key = chunk_clone(session_key);
-       this->remote_endpoints = endpoints->clone_offset(endpoints, offsetof(endpoint_notify_t, clone));
-       this->response = response;
-}
-
-/**
- * Implementation of task_t.get_type
- */
-static task_type_t get_type(private_ike_p2p_t *this)
-{
-       return IKE_P2P;
-}
-
-/**
- * Implementation of task_t.migrate
- */
-static void migrate(private_ike_p2p_t *this, ike_sa_t *ike_sa)
-{
-       this->ike_sa = ike_sa;
-}
-
-/**
- * Implementation of task_t.destroy
- */
-static void destroy(private_ike_p2p_t *this)
-{
-       DESTROY_IF(this->peer_id);
-       
-       chunk_free(&this->session_id);
-       chunk_free(&this->session_key);
-       
-       this->local_endpoints->destroy_offset(this->local_endpoints, offsetof(endpoint_notify_t, destroy));
-       this->remote_endpoints->destroy_offset(this->remote_endpoints, offsetof(endpoint_notify_t, destroy));
-       
-       DESTROY_IF(this->mediated_cfg);
-       free(this);
-}
-
-/*
- * Described in header.
- */
-ike_p2p_t *ike_p2p_create(ike_sa_t *ike_sa, bool initiator)
-{
-       private_ike_p2p_t *this = malloc_thing(private_ike_p2p_t);
-
-       this->public.task.get_type = (task_type_t(*)(task_t*))get_type;
-       this->public.task.migrate = (void(*)(task_t*,ike_sa_t*))migrate;
-       this->public.task.destroy = (void(*)(task_t*))destroy;
-       
-       ike_sa_id_t *id = ike_sa->get_id(ike_sa);
-       if (id->is_initiator(id))
-       {
-               if (initiator)
-               {
-                       this->public.task.build = (status_t(*)(task_t*,message_t*))build_i;
-                       this->public.task.process = (status_t(*)(task_t*,message_t*))process_i;
-               }
-               else
-               {
-                       this->public.task.build = (status_t(*)(task_t*,message_t*))build_r;
-                       this->public.task.process = (status_t(*)(task_t*,message_t*))process_r;
-               }
-       }
-       else
-       {
-               /* mediation server */
-               if (initiator)
-               {
-                       this->public.task.build = (status_t(*)(task_t*,message_t*))build_i_ms;
-                       this->public.task.process = (status_t(*)(task_t*,message_t*))process_i_ms;
-               }
-               else
-               {
-                       this->public.task.build = (status_t(*)(task_t*,message_t*))build_r_ms;
-                       this->public.task.process = (status_t(*)(task_t*,message_t*))process_r_ms;
-               }
-       }
-       
-       this->public.connect = (void(*)(ike_p2p_t*,identification_t*))p2p_connect;
-       this->public.respond = (void(*)(ike_p2p_t*,identification_t*,chunk_t))p2p_respond;
-       this->public.callback = (void(*)(ike_p2p_t*,identification_t*))p2p_callback;
-       this->public.relay = (void(*)(ike_p2p_t*,identification_t*,chunk_t,chunk_t,linked_list_t*,bool))relay;
-       
-       this->ike_sa = ike_sa;
-       this->initiator = initiator;
-       
-       this->peer_id = NULL;
-       this->session_id = chunk_empty;
-       this->session_key = chunk_empty;
-       this->local_endpoints = linked_list_create();
-       this->remote_endpoints = linked_list_create();
-       this->mediation = FALSE;
-       this->response = FALSE;
-       this->callback = FALSE;
-       this->failed = FALSE;
-       this->invalid_syntax = FALSE;
-       
-       this->mediated_cfg = NULL;
-       
-       return &this->public;
-}
diff --git a/src/charon/sa/tasks/ike_p2p.h b/src/charon/sa/tasks/ike_p2p.h
deleted file mode 100644 (file)
index fe6bbd1..0000000
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * Copyright (C) 2007 Tobias Brunner
- * Hochschule fuer Technik Rapperswil
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation; either version 2 of the License, or (at your
- * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * for more details.
- *
- * $Id$
- */
-
-/**
- * @defgroup ike_p2p ike_p2p
- * @{ @ingroup tasks
- */
-
-#ifndef IKE_P2P_H_
-#define IKE_P2P_H_
-
-typedef struct ike_p2p_t ike_p2p_t;
-
-#include <library.h>
-#include <sa/ike_sa.h>
-#include <sa/tasks/task.h>
-
-/**
- * Task of type IKE_P2P, detects and handles P2P-NAT-T extensions.
- *
- * This tasks handles the P2P_MEDIATION notify exchange to setup a mediation
- * connection, allows to initiate mediated connections using P2P_CONNECT
- * exchanges and to request reflexive addresses from the mediation server using
- * P2P_ENDPOINT notifies.
- * 
- * @note This task has to be activated before the IKE_AUTH task, because that
- * task generates the IKE_SA_INIT message so that no more payloads can be added
- * to it afterwards.
- */
-struct ike_p2p_t {
-
-       /**
-        * Implements the task_t interface
-        */
-       task_t task;
-       
-       /**
-        * Initiates a connection with another peer (i.e. sends a P2P_CONNECT
-        * to the mediation server)
-        *
-        * @param peer_id                       ID of the other peer (gets cloned)
-        */
-       void (*connect)(ike_p2p_t *this, identification_t *peer_id);
-       
-       /**
-        * Responds to a P2P_CONNECT from another peer (i.e. sends a P2P_CONNECT
-        * to the mediation server)
-        * 
-        * @param peer_id                       ID of the other peer (gets cloned)
-        * @param session_id            the session ID as provided by the initiator (gets cloned)
-        */
-       void (*respond)(ike_p2p_t *this, identification_t *peer_id, chunk_t session_id);
-       
-       /**
-        * Sends a P2P_CALLBACK to a peer that previously requested another peer.
-        * 
-        * @param peer_id                       ID of the other peer (gets cloned)
-        */
-       void (*callback)(ike_p2p_t *this, identification_t *peer_id);
-       
-       /**
-        * Relays data to another peer (i.e. sends a P2P_CONNECT to the peer)
-        * 
-        * Data gets cloned.
-        * 
-        * @param requester                     ID of the requesting peer
-        * @param session_id            content of the P2P_SESSIONID notify
-        * @param session_key           content of the P2P_SESSIONKEY notify
-        * @param endpoints                     endpoints
-        * @param response                      TRUE if this is a response
-        */
-       void (*relay)(ike_p2p_t *this, identification_t *requester, chunk_t session_id,
-                       chunk_t session_key, linked_list_t *endpoints, bool response);
-
-};
-
-/**
- * Create a new ike_p2p task.
- *
- * @param ike_sa               IKE_SA this task works for
- * @param initiator            TRUE if taks is initiated by us
- * @return                             ike_p2p task to handle by the task_manager
- */
-ike_p2p_t *ike_p2p_create(ike_sa_t *ike_sa, bool initiator);
-
-#endif /*IKE_P2P_H_ @} */
index 0ff2afd..4ff50a6 100644 (file)
@@ -31,9 +31,9 @@ ENUM(task_type_names, IKE_INIT, CHILD_REKEY,
        "IKE_REAUTH",
        "IKE_DELETE",
        "IKE_DPD",
-#ifdef P2P
-       "IKE_P2P",
-#endif /* P2P */
+#ifdef ME
+       "IKE_ME",
+#endif /* ME */
        "CHILD_CREATE",
        "CHILD_DELETE",
        "CHILD_REKEY",
index 773bc60..d285470 100644 (file)
@@ -59,10 +59,10 @@ enum task_type_t {
        IKE_DELETE,
        /** liveness check */
        IKE_DPD,
-#ifdef P2P
-       /** handle P2P-NAT-T stuff */
-       IKE_P2P,
-#endif /* P2P */
+#ifdef ME
+       /** handle ME stuff */
+       IKE_ME,
+#endif /* ME */
        /** establish a CHILD_SA within an IKE_SA */
        CHILD_CREATE,
        /** delete an established CHILD_SA */
index 2520bf8..479321c 100644 (file)
@@ -210,9 +210,9 @@ static const token_info_t token_info[] =
     { ARG_ENUM, offsetof(starter_conn_t, dpd_action), LST_dpd_action               },
     { ARG_MISC, 0, NULL  /* KW_MODECONFIG */                                       },
     { ARG_MISC, 0, NULL  /* KW_XAUTH */                                            },
-    { ARG_ENUM, offsetof(starter_conn_t, p2p_mediation), LST_bool                  },
-    { ARG_STR,  offsetof(starter_conn_t, p2p_mediated_by), NULL                    },
-    { ARG_STR,  offsetof(starter_conn_t, p2p_peerid), NULL                         },
+    { ARG_ENUM, offsetof(starter_conn_t, me_mediation), LST_bool                  },
+    { ARG_STR,  offsetof(starter_conn_t, me_mediated_by), NULL                    },
+    { ARG_STR,  offsetof(starter_conn_t, me_peerid), NULL                         },
 
     /* ca section keywords */
     { ARG_STR,  offsetof(starter_ca_t, name), NULL                                 },
index 3270eab..b866a91 100644 (file)
@@ -130,9 +130,9 @@ struct starter_conn {
        dpd_action_t    dpd_action;
        int             dpd_count;
        
-       bool            p2p_mediation;
-       char            *p2p_mediated_by;
-       char            *p2p_peerid;
+       bool            me_mediation;
+       char            *me_mediated_by;
+       char            *me_peerid;
 
        starter_conn_t *next;
 };
index e1957b3..79e4e4e 100644 (file)
@@ -87,12 +87,12 @@ typedef enum {
     KW_DPDACTION,
     KW_MODECONFIG,
     KW_XAUTH,
-    KW_P2P_MEDIATION,
-    KW_P2P_MEDIATED_BY,
-    KW_P2P_PEERID,
+    KW_ME_MEDIATION,
+    KW_ME_MEDIATED_BY,
+    KW_ME_PEERID,
 
 #define KW_CONN_FIRST  KW_CONN_SETUP
-#define KW_CONN_LAST   KW_P2P_PEERID
+#define KW_CONN_LAST   KW_ME_PEERID
 
    /* ca section keywords */
     KW_CA_NAME,
index bcadb17..97bb4e4 100644 (file)
@@ -76,9 +76,9 @@ dpdtimeout,        KW_DPDTIMEOUT
 dpdaction,         KW_DPDACTION
 modeconfig,        KW_MODECONFIG
 xauth,             KW_XAUTH
-p2p_mediation,     KW_P2P_MEDIATION
-p2p_mediated_by,   KW_P2P_MEDIATED_BY
-p2p_peerid,        KW_P2P_PEERID
+p2p_mediation,     KW_ME_MEDIATION
+p2p_mediated_by,   KW_ME_MEDIATED_BY
+p2p_peerid,        KW_ME_PEERID
 cacert,            KW_CACERT
 ldaphost,          KW_LDAPHOST
 ldapbase,          KW_LDAPBASE
index 0ce0937..83db143 100644 (file)
@@ -237,9 +237,9 @@ int starter_stroke_add_conn(starter_config_t *cfg, starter_conn_t *conn)
        msg.add_conn.algorithms.esp = push_string(&msg, conn->esp);
        msg.add_conn.dpd.delay = conn->dpd_delay;
        msg.add_conn.dpd.action = conn->dpd_action;
-       msg.add_conn.p2p.mediation = conn->p2p_mediation;
-       msg.add_conn.p2p.mediated_by = push_string(&msg, conn->p2p_mediated_by);
-       msg.add_conn.p2p.peerid = push_string(&msg, conn->p2p_peerid);
+       msg.add_conn.ikeme.mediation = conn->me_mediation;
+       msg.add_conn.ikeme.mediated_by = push_string(&msg, conn->me_mediated_by);
+       msg.add_conn.ikeme.peerid = push_string(&msg, conn->me_peerid);
 
        starter_stroke_add_end(&msg, &msg.add_conn.me, &conn->left);
        starter_stroke_add_end(&msg, &msg.add_conn.other, &conn->right);
index 6b2e33d..3f2a661 100644 (file)
@@ -129,9 +129,9 @@ static int add_connection(char *name,
        msg.add_conn.dpd.delay = 0;
        msg.add_conn.dpd.action = 1;
        
-       msg.add_conn.p2p.mediation = 0;
-       msg.add_conn.p2p.mediated_by = NULL;
-       msg.add_conn.p2p.peerid = NULL;
+       msg.add_conn.ikeme.mediation = 0;
+       msg.add_conn.ikeme.mediated_by = NULL;
+       msg.add_conn.ikeme.peerid = NULL;
        
        msg.add_conn.me.id = push_string(&msg, my_id);
        msg.add_conn.me.address = push_string(&msg, my_addr);
index 1af3c6e..c48ebe8 100644 (file)
@@ -218,7 +218,7 @@ struct stroke_msg_t {
                                int mediation;
                                char *mediated_by;
                                char *peerid;
-                       } p2p;
+                       } ikeme;
                        stroke_end_t me, other;
                } add_conn;
 
index 0036e07..e59334d 100644 (file)
@@ -2,10 +2,10 @@ alice::ipsec statusall::medsrv.*ESTABLISHED::YES
 venus::ipsec statusall::medsrv.*ESTABLISHED::YES
 carol::ipsec statusall::medsrv.*ESTABLISHED.*PH_IP_MOON.*6cu1UTVw@medsrv.org::YES
 carol::ipsec statusall::medsrv.*ESTABLISHED.*PH_IP_MOON.*F1ubAio8@medsrv.org::YES
-alice::cat /var/log/daemon.log::received P2P_CALLBACK::YES
-alice::ipsec statusall::p2p.*ESTABLISHED::YES
-venus::ipsec statusall::p2p.*ESTABLISHED::YES
-alice::ipsec statusall::p2p.*INSTALLED::YES
-venus::ipsec statusall::p2p.*INSTALLED::YES
+alice::cat /var/log/daemon.log::received ME_CALLBACK::YES
+alice::ipsec statusall::peer.*ESTABLISHED::YES
+venus::ipsec statusall::peer.*ESTABLISHED::YES
+alice::ipsec statusall::peer.*INSTALLED::YES
+venus::ipsec statusall::peer.*INSTALLED::YES
 alice::ping -c 1 PH_IP_VENUS::64 bytes from PH_IP_VENUS: icmp_seq=1::YES
 venus::ping -c 1 PH_IP_ALICE::64 bytes from PH_IP_ALICE: icmp_seq=1::YES
index 9374869..1eb88c1 100755 (executable)
@@ -25,7 +25,7 @@ start() {
         iptables -A INPUT  -i eth0 -p udp --sport 500 --dport 500 -j ACCEPT
         iptables -A OUTPUT -o eth0 -p udp --dport 500 --sport 500 -j ACCEPT
                        
-       # allow NAT-T including P2P 
+       # allow NAT-T 
        iptables -A INPUT  -i eth0 -p udp --dport 4500 -j ACCEPT
        iptables -A OUTPUT -o eth0 -p udp --sport 4500 -j ACCEPT
 
index e481996..6ddb04a 100755 (executable)
@@ -25,7 +25,7 @@ conn medsrv
        authby=psk
        auto=add
 
-conn p2p 
+conn peer
        leftcert=aliceCert.pem
        leftid=alice@strongswan.org
        right=%any
index 06d0ebc..6fca87b 100755 (executable)
@@ -25,7 +25,7 @@ start() {
         iptables -A INPUT  -i eth0 -p udp --sport 500 --dport 500 -j ACCEPT
         iptables -A OUTPUT -o eth0 -p udp --dport 500 --sport 500 -j ACCEPT
                        
-       # allow NAT-T including P2P 
+       # allow NAT-T
        iptables -A INPUT  -i eth0 -p udp --dport 4500 -j ACCEPT
        iptables -A OUTPUT -o eth0 -p udp --sport 4500 -j ACCEPT
 
index d210093..0a4bb64 100755 (executable)
@@ -25,7 +25,7 @@ conn medsrv
        p2p_mediation=yes
        auto=start
 
-conn p2p 
+conn peer 
        leftcert=venusCert.pem
        leftid=@venus.strongswan.org
        right=%any
index b8280c3..ba14bb8 100644 (file)
@@ -2,10 +2,10 @@ alice::ipsec statusall::medsrv.*ESTABLISHED::YES
 bob::ipsec statusall::medsrv.*ESTABLISHED::YES
 carol::ipsec statusall::medsrv.*ESTABLISHED.*PH_IP_MOON.*6cu1UTVw@medsrv.org::YES
 carol::ipsec statusall::medsrv.*ESTABLISHED.*PH_IP_SUN.*v9oEPMz@medsrv.org::YES
-alice::ipsec statusall::p2p.*ESTABLISHED::YES
-bob::ipsec statusall::p2p.*ESTABLISHED::YES
-alice::ipsec statusall::p2p.*INSTALLED::YES
-bob::ipsec statusall::p2p.*INSTALLED::YES
+alice::ipsec statusall::peer.*ESTABLISHED::YES
+bob::ipsec statusall::peer.*ESTABLISHED::YES
+alice::ipsec statusall::peer.*INSTALLED::YES
+bob::ipsec statusall::peer.*INSTALLED::YES
 alice::ping -c 1 PH_IP_BOB::64 bytes from PH_IP_BOB: icmp_seq=1::YES
 bob::ping -c 1 PH_IP_ALICE::64 bytes from PH_IP_ALICE: icmp_seq=1::YES
 moon::tcpdump::IP moon.strongswan.org.* > sun.strongswan.org.*: UDP::YES
index 09b4cab..c6371c7 100755 (executable)
@@ -21,7 +21,7 @@ start() {
         iptables -A INPUT  -i eth0 -p udp --sport 500 --dport 500 -j ACCEPT
         iptables -A OUTPUT -o eth0 -p udp --dport 500 --sport 500 -j ACCEPT
                        
-       # allow NAT-T including P2P 
+       # allow NAT-T
        iptables -A INPUT  -i eth0 -p udp --dport 4500 -j ACCEPT
        iptables -A OUTPUT -o eth0 -p udp --sport 4500 -j ACCEPT
 
index 370934c..8dd4142 100755 (executable)
@@ -25,7 +25,7 @@ conn medsrv
        authby=psk
        auto=add
 
-conn p2p 
+conn peer 
        leftcert=aliceCert.pem
        leftid=alice@strongswan.org
        right=%any
index 8d8d939..abf4320 100755 (executable)
@@ -25,7 +25,7 @@ conn medsrv
        p2p_mediation=yes
        auto=start
 
-conn p2p 
+conn peer
        leftcert=bobCert.pem
        leftid=bob@strongswan.org
        right=%any