Added IKEv1 support to delete payload

[strongswan.git] / src / libcharon / sa / tasks / child_delete.c

diff --git a/src/libcharon/sa/tasks/child_delete.c b/src/libcharon/sa/tasks/child_delete.c
index d7c6b05..e730746 100644 (file)
--- a/src/libcharon/sa/tasks/child_delete.c
+++ b/src/libcharon/sa/tasks/child_delete.c
@@ -73,11 +73,11 @@ struct private_child_delete_t {
 static void build_payloads(private_child_delete_t *this, message_t *message)
 {
        delete_payload_t *ah = NULL, *esp = NULL;
 static void build_payloads(private_child_delete_t *this, message_t *message)
 {
        delete_payload_t *ah = NULL, *esp = NULL;

-       iterator_t *iterator;
+       enumerator_t *enumerator;

        child_sa_t *child_sa;
 
        child_sa_t *child_sa;
 

-       iterator = this->child_sas->create_iterator(this->child_sas, TRUE);
-       while (iterator->iterate(iterator, (void**)&child_sa))
+       enumerator = this->child_sas->create_enumerator(this->child_sas);
+       while (enumerator->enumerate(enumerator, (void**)&child_sa))

        {
                protocol_id_t protocol = child_sa->get_protocol(child_sa);
                u_int32_t spi = child_sa->get_spi(child_sa, TRUE);
        {
                protocol_id_t protocol = child_sa->get_protocol(child_sa);
                u_int32_t spi = child_sa->get_spi(child_sa, TRUE);


@@ -87,7 +87,7 @@ static void build_payloads(private_child_delete_t *this, message_t *message)
                        case PROTO_ESP:
                                if (esp == NULL)
                                {
                        case PROTO_ESP:
                                if (esp == NULL)
                                {

-                                       esp = delete_payload_create(PROTO_ESP);
+                                       esp = delete_payload_create(DELETE, PROTO_ESP);

                                        message->add_payload(message, (payload_t*)esp);
                                }
                                esp->add_spi(esp, spi);
                                        message->add_payload(message, (payload_t*)esp);
                                }
                                esp->add_spi(esp, spi);


@@ -97,7 +97,7 @@ static void build_payloads(private_child_delete_t *this, message_t *message)
                        case PROTO_AH:
                                if (ah == NULL)
                                {
                        case PROTO_AH:
                                if (ah == NULL)
                                {

-                                       ah = delete_payload_create(PROTO_AH);
+                                       ah = delete_payload_create(DELETE, PROTO_AH);

                                        message->add_payload(message, (payload_t*)ah);
                                }
                                ah->add_spi(ah, spi);
                                        message->add_payload(message, (payload_t*)ah);
                                }
                                ah->add_spi(ah, spi);


@@ -109,7 +109,7 @@ static void build_payloads(private_child_delete_t *this, message_t *message)
                }
                child_sa->set_state(child_sa, CHILD_DELETING);
        }
                }
                child_sa->set_state(child_sa, CHILD_DELETING);
        }

-       iterator->destroy(iterator);
+       enumerator->destroy(enumerator);

 }
 
 /**
 }
 
 /**


@@ -117,11 +117,10 @@ static void build_payloads(private_child_delete_t *this, message_t *message)
  */
 static void process_payloads(private_child_delete_t *this, message_t *message)
 {
  */
 static void process_payloads(private_child_delete_t *this, message_t *message)
 {

-       enumerator_t *payloads;
-       iterator_t *spis;
+       enumerator_t *payloads, *spis;

        payload_t *payload;
        delete_payload_t *delete_payload;
        payload_t *payload;
        delete_payload_t *delete_payload;

-       u_int32_t *spi;
+       u_int32_t spi;

        protocol_id_t protocol;
        child_sa_t *child_sa;
 
        protocol_id_t protocol;
        child_sa_t *child_sa;
 


@@ -136,19 +135,19 @@ static void process_payloads(private_child_delete_t *this, message_t *message)
                        {
                                continue;
                        }
                        {
                                continue;
                        }

-                       spis = delete_payload->create_spi_iterator(delete_payload);
-                       while (spis->iterate(spis, (void**)&spi))
+                       spis = delete_payload->create_spi_enumerator(delete_payload);
+                       while (spis->enumerate(spis, &spi))

                        {
                                child_sa = this->ike_sa->get_child_sa(this->ike_sa, protocol,
                        {
                                child_sa = this->ike_sa->get_child_sa(this->ike_sa, protocol,

-                                                                                                         *spi, FALSE);
+                                                                                                         spi, FALSE);

                                if (child_sa == NULL)
                                {
                                        DBG1(DBG_IKE, "received DELETE for %N CHILD_SA with SPI %.8x, "
                                if (child_sa == NULL)
                                {
                                        DBG1(DBG_IKE, "received DELETE for %N CHILD_SA with SPI %.8x, "

-                                                "but no such SA", protocol_id_names, protocol, ntohl(*spi));
+                                                "but no such SA", protocol_id_names, protocol, ntohl(spi));

                                        continue;
                                }
                                DBG1(DBG_IKE, "received DELETE for %N CHILD_SA with SPI %.8x",
                                        continue;
                                }
                                DBG1(DBG_IKE, "received DELETE for %N CHILD_SA with SPI %.8x",

-                                               protocol_id_names, protocol, ntohl(*spi));
+                                        protocol_id_names, protocol, ntohl(spi));

 
                                switch (child_sa->get_state(child_sa))
                                {
 
                                switch (child_sa->get_state(child_sa))
                                {


@@ -161,9 +160,10 @@ static void process_payloads(private_child_delete_t *this, message_t *message)
                                                if (!this->initiator)
                                                {
                                                        this->ike_sa->destroy_child_sa(this->ike_sa,
                                                if (!this->initiator)
                                                {
                                                        this->ike_sa->destroy_child_sa(this->ike_sa,

-                                                                                                                  protocol, *spi);
+                                                                                                                  protocol, spi);

                                                        continue;
                                                }
                                                        continue;
                                                }

+                                               /* fall through */

                                        case CHILD_INSTALLED:
                                                if (!this->initiator)
                                                {       /* reestablish installed children if required */
                                        case CHILD_INSTALLED:
                                                if (!this->initiator)
                                                {       /* reestablish installed children if required */


@@ -186,15 +186,16 @@ static void process_payloads(private_child_delete_t *this, message_t *message)
  */
 static status_t destroy_and_reestablish(private_child_delete_t *this)
 {
  */
 static status_t destroy_and_reestablish(private_child_delete_t *this)
 {

-       iterator_t *iterator;
+       enumerator_t *enumerator;

        child_sa_t *child_sa;
        child_cfg_t *child_cfg;
        protocol_id_t protocol;
        u_int32_t spi;
        child_sa_t *child_sa;
        child_cfg_t *child_cfg;
        protocol_id_t protocol;
        u_int32_t spi;

+       action_t action;

        status_t status = SUCCESS;
 
        status_t status = SUCCESS;
 

-       iterator = this->child_sas->create_iterator(this->child_sas, TRUE);
-       while (iterator->iterate(iterator, (void**)&child_sa))
+       enumerator = this->child_sas->create_enumerator(this->child_sas);
+       while (enumerator->enumerate(enumerator, (void**)&child_sa))

        {
                /* signal child down event if we are not rekeying */
                if (!this->rekeyed)
        {
                /* signal child down event if we are not rekeying */
                if (!this->rekeyed)


@@ -205,10 +206,11 @@ static status_t destroy_and_reestablish(private_child_delete_t *this)
                protocol = child_sa->get_protocol(child_sa);
                child_cfg = child_sa->get_config(child_sa);
                child_cfg->get_ref(child_cfg);
                protocol = child_sa->get_protocol(child_sa);
                child_cfg = child_sa->get_config(child_sa);
                child_cfg->get_ref(child_cfg);

+               action = child_sa->get_close_action(child_sa);

                this->ike_sa->destroy_child_sa(this->ike_sa, protocol, spi);
                if (this->check_delete_action)
                {       /* enforce child_cfg policy if deleted passively */
                this->ike_sa->destroy_child_sa(this->ike_sa, protocol, spi);
                if (this->check_delete_action)
                {       /* enforce child_cfg policy if deleted passively */

-                       switch (child_cfg->get_close_action(child_cfg))
+                       switch (action)

                        {
                                case ACTION_RESTART:
                                        child_cfg->get_ref(child_cfg);
                        {
                                case ACTION_RESTART:
                                        child_cfg->get_ref(child_cfg);


@@ -229,7 +231,7 @@ static status_t destroy_and_reestablish(private_child_delete_t *this)
                        break;
                }
        }
                        break;
                }
        }

-       iterator->destroy(iterator);
+       enumerator->destroy(enumerator);

        return status;
 }
 
        return status;
 }
 


@@ -238,12 +240,12 @@ static status_t destroy_and_reestablish(private_child_delete_t *this)
  */
 static void log_children(private_child_delete_t *this)
 {
  */
 static void log_children(private_child_delete_t *this)
 {

-       iterator_t *iterator;
+       enumerator_t *enumerator;

        child_sa_t *child_sa;
        u_int64_t bytes_in, bytes_out;
 
        child_sa_t *child_sa;
        u_int64_t bytes_in, bytes_out;
 

-       iterator = this->child_sas->create_iterator(this->child_sas, TRUE);
-       while (iterator->iterate(iterator, (void**)&child_sa))
+       enumerator = this->child_sas->create_enumerator(this->child_sas);
+       while (enumerator->enumerate(enumerator, (void**)&child_sa))

        {
                child_sa->get_usestats(child_sa, TRUE, NULL, &bytes_in);
                child_sa->get_usestats(child_sa, FALSE, NULL, &bytes_out);
        {
                child_sa->get_usestats(child_sa, TRUE, NULL, &bytes_in);
                child_sa->get_usestats(child_sa, FALSE, NULL, &bytes_out);


@@ -256,13 +258,11 @@ static void log_children(private_child_delete_t *this)
                         child_sa->get_traffic_selectors(child_sa, TRUE),
                         child_sa->get_traffic_selectors(child_sa, FALSE));
        }
                         child_sa->get_traffic_selectors(child_sa, TRUE),
                         child_sa->get_traffic_selectors(child_sa, FALSE));
        }

-       iterator->destroy(iterator);
+       enumerator->destroy(enumerator);

 }
 
 }
 

-/**
- * Implementation of task_t.build for initiator
- */
-static status_t build_i(private_child_delete_t *this, message_t *message)
+METHOD(task_t, build_i, status_t,
+       private_child_delete_t *this, message_t *message)

 {
        child_sa_t *child_sa;
 
 {
        child_sa_t *child_sa;
 


@@ -289,10 +289,8 @@ static status_t build_i(private_child_delete_t *this, message_t *message)
        return NEED_MORE;
 }
 
        return NEED_MORE;
 }
 

-/**
- * Implementation of task_t.process for initiator
- */
-static status_t process_i(private_child_delete_t *this, message_t *message)
+METHOD(task_t, process_i, status_t,
+       private_child_delete_t *this, message_t *message)

 {
        /* flush the list before adding new SAs */
        this->child_sas->destroy(this->child_sas);
 {
        /* flush the list before adding new SAs */
        this->child_sas->destroy(this->child_sas);


@@ -303,20 +301,16 @@ static status_t process_i(private_child_delete_t *this, message_t *message)
        return destroy_and_reestablish(this);
 }
 
        return destroy_and_reestablish(this);
 }
 

-/**
- * Implementation of task_t.process for initiator
- */
-static status_t process_r(private_child_delete_t *this, message_t *message)
+METHOD(task_t, process_r, status_t,
+       private_child_delete_t *this, message_t *message)

 {
        process_payloads(this, message);
        log_children(this);
        return NEED_MORE;
 }
 
 {
        process_payloads(this, message);
        log_children(this);
        return NEED_MORE;
 }
 

-/**
- * Implementation of task_t.build for responder
- */
-static status_t build_r(private_child_delete_t *this, message_t *message)
+METHOD(task_t, build_r, status_t,
+       private_child_delete_t *this, message_t *message)

 {
        /* if we are rekeying, we send an empty informational */
        if (this->ike_sa->get_state(this->ike_sa) != IKE_REKEYING)
 {
        /* if we are rekeying, we send an empty informational */
        if (this->ike_sa->get_state(this->ike_sa) != IKE_REKEYING)


@@ -327,28 +321,22 @@ static status_t build_r(private_child_delete_t *this, message_t *message)
        return destroy_and_reestablish(this);
 }
 
        return destroy_and_reestablish(this);
 }
 

-/**
- * Implementation of task_t.get_type
- */
-static task_type_t get_type(private_child_delete_t *this)
+METHOD(task_t, get_type, task_type_t,
+       private_child_delete_t *this)

 {
        return CHILD_DELETE;
 }
 
 {
        return CHILD_DELETE;
 }
 

-/**
- * Implementation of child_delete_t.get_child
- */
-static child_sa_t* get_child(private_child_delete_t *this)
+METHOD(child_delete_t , get_child, child_sa_t*,
+       private_child_delete_t *this)

 {
        child_sa_t *child_sa = NULL;
        this->child_sas->get_first(this->child_sas, (void**)&child_sa);
        return child_sa;
 }
 
 {
        child_sa_t *child_sa = NULL;
        this->child_sas->get_first(this->child_sas, (void**)&child_sa);
        return child_sa;
 }
 

-/**
- * Implementation of task_t.migrate
- */
-static void migrate(private_child_delete_t *this, ike_sa_t *ike_sa)
+METHOD(task_t, migrate, void,
+       private_child_delete_t *this, ike_sa_t *ike_sa)

 {
        this->check_delete_action = FALSE;
        this->ike_sa = ike_sa;
 {
        this->check_delete_action = FALSE;
        this->ike_sa = ike_sa;


@@ -357,10 +345,8 @@ static void migrate(private_child_delete_t *this, ike_sa_t *ike_sa)
        this->child_sas = linked_list_create();
 }
 
        this->child_sas = linked_list_create();
 }
 

-/**
- * Implementation of task_t.destroy
- */
-static void destroy(private_child_delete_t *this)
+METHOD(task_t, destroy, void,
+       private_child_delete_t *this)

 {
        this->child_sas->destroy(this->child_sas);
        free(this);
 {
        this->child_sas->destroy(this->child_sas);
        free(this);


@@ -372,30 +358,33 @@ static void destroy(private_child_delete_t *this)
 child_delete_t *child_delete_create(ike_sa_t *ike_sa, protocol_id_t protocol,
                                                                        u_int32_t spi)
 {
 child_delete_t *child_delete_create(ike_sa_t *ike_sa, protocol_id_t protocol,
                                                                        u_int32_t spi)
 {

-       private_child_delete_t *this = malloc_thing(private_child_delete_t);
-
-       this->public.get_child = (child_sa_t*(*)(child_delete_t*))get_child;
-       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;
-
-       this->ike_sa = ike_sa;
-       this->check_delete_action = FALSE;
-       this->child_sas = linked_list_create();
-       this->protocol = protocol;
-       this->spi = spi;
-       this->rekeyed = FALSE;
+       private_child_delete_t *this;
+
+       INIT(this,
+               .public = {
+                       .task = {
+                               .get_type = _get_type,
+                               .migrate = _migrate,
+                               .destroy = _destroy,
+                       },
+                       .get_child = _get_child,
+               },
+               .ike_sa = ike_sa,
+               .child_sas = linked_list_create(),
+               .protocol = protocol,
+               .spi = spi,
+       );

 
        if (protocol != PROTO_NONE)
        {
 
        if (protocol != PROTO_NONE)
        {

-               this->public.task.build = (status_t(*)(task_t*,message_t*))build_i;
-               this->public.task.process = (status_t(*)(task_t*,message_t*))process_i;
+               this->public.task.build = _build_i;
+               this->public.task.process = _process_i;

                this->initiator = TRUE;
        }
        else
        {
                this->initiator = TRUE;
        }
        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;
+               this->public.task.build = _build_r;
+               this->public.task.process = _process_r;

                this->initiator = FALSE;
        }
        return &this->public;
                this->initiator = FALSE;
        }
        return &this->public;