strongSwan

static payload_order_t ike_sa_init_i_payload_order[] = {

/*	payload type					notify type */

	{NOTIFY,						COOKIE},

	{NOTIFY,						NAT_DETECTION_SOURCE_IP},

	{NOTIFY,						NAT_DETECTION_DESTINATION_IP},

	{NOTIFY,						0},

 */

static payload_order_t ike_sa_init_r_payload_order[] = {

/*	payload type					notify type */

	{NOTIFY,						NAT_DETECTION_SOURCE_IP},

	{NOTIFY,						NAT_DETECTION_DESTINATION_IP},

	{NOTIFY,						HTTP_CERT_LOOKUP_SUPPORTED},

	{NOTIFY,						USE_TRANSPORT_MODE},

	{NOTIFY,						ESP_TFC_PADDING_NOT_SUPPORTED},

	{NOTIFY,						NON_FIRST_FRAGMENTS_ALSO},

	{TRAFFIC_SELECTOR_INITIATOR,	0},

	{TRAFFIC_SELECTOR_RESPONDER,	0},

	{NOTIFY,						MOBIKE_SUPPORTED},

	{NOTIFY,						USE_TRANSPORT_MODE},

	{NOTIFY,						ESP_TFC_PADDING_NOT_SUPPORTED},

	{NOTIFY,						NON_FIRST_FRAGMENTS_ALSO},

	{TRAFFIC_SELECTOR_INITIATOR,	0},

	{TRAFFIC_SELECTOR_RESPONDER,	0},

	{NOTIFY,						AUTH_LIFETIME},

	{NOTIFY,						USE_TRANSPORT_MODE},

	{NOTIFY,						ESP_TFC_PADDING_NOT_SUPPORTED},

	{NOTIFY,						NON_FIRST_FRAGMENTS_ALSO},

	{NONCE,							0},

	{TRAFFIC_SELECTOR_INITIATOR,	0},

	{TRAFFIC_SELECTOR_RESPONDER,	0},

	{NOTIFY,						0},

	{NOTIFY,						USE_TRANSPORT_MODE},

	{NOTIFY,						ESP_TFC_PADDING_NOT_SUPPORTED},

	{NOTIFY,						NON_FIRST_FRAGMENTS_ALSO},

	{NONCE,							0},

	{TRAFFIC_SELECTOR_INITIATOR,	0},

	{TRAFFIC_SELECTOR_RESPONDER,	0},

	{NOTIFY,						ADDITIONAL_TS_POSSIBLE},

/**

 * Implementation of private_message_t.get_payload_rule.

 */

{

	int i;

/**

 * Implementation of message_t.set_ike_sa_id.

 */

{

	DESTROY_IF(this->ike_sa_id);

	this->ike_sa_id = ike_sa_id->clone(ike_sa_id);

/**

 * Implementation of message_t.get_ike_sa_id.

 */

{

	return this->ike_sa_id;

}

/**

 * Implementation of message_t.set_message_id.

 */

{

	this->message_id = message_id;

}

/**

 * Implementation of message_t.get_message_id.

 */

{

	return this->message_id;

}

/**

 * Implementation of message_t.get_initiator_spi.

 */

{

	return (this->ike_sa_id->get_initiator_spi(this->ike_sa_id));

}

/**

 * Implementation of message_t.get_responder_spi.

 */

{

	return (this->ike_sa_id->get_responder_spi(this->ike_sa_id));

}

/**

 * Implementation of message_t.set_major_version.

 */

{

	this->major_version = major_version;

}

/**

 * Implementation of message_t.set_major_version.

 */

{

	return this->major_version;

}

/**

 * Implementation of message_t.set_minor_version.

 */

{

	this->minor_version = minor_version;

}

/**

 * Implementation of message_t.get_minor_version.

 */

{

	return this->minor_version;

}

/**

 * Implementation of message_t.set_exchange_type.

 */

{

	this->exchange_type = exchange_type;

}

/**

 * Implementation of message_t.get_exchange_type.

 */

{

	return this->exchange_type;

}

/**

 * Implementation of message_t.get_first_payload_type.

 */

{

	return this->first_payload;

}

/**

 * Implementation of message_t.set_request.

 */

{

	this->is_request = request;

}

/**

 * Implementation of message_t.get_request.

 */

{

	return this->is_request;

}

	ike_header->set_exchange_type(ike_header, this->exchange_type);

	ike_header->set_message_id(ike_header, this->message_id);

	ike_header->set_response_flag(ike_header, !this->is_request);

	generator = generator_create();

/**

 * Implementation of message_t.get_packet.

 */

{

	if (this->packet == NULL)

	{

/**

 * Implementation of message_t.get_packet_data.

 */

{

	if (this->packet == NULL)

	{

	DBG2(DBG_ENC, "parsing header of message");

	this->parser->reset_context(this->parser);

	if (status != SUCCESS)

	{

		DBG1(DBG_ENC, "header could not be parsed");

	}

	/* verify payload */

	if (status != SUCCESS)

	{

		DBG1(DBG_ENC, "header verification failed");

	}

	this->ike_sa_id = ike_sa_id_create(ike_header->get_initiator_spi(ike_header),

	this->exchange_type = ike_header->get_exchange_type(ike_header);

	this->message_id = ike_header->get_message_id(ike_header);

	this->is_request = (!(ike_header->get_response_flag(ike_header)));

	this->major_version = ike_header->get_maj_version(ike_header);

	this->minor_version = ike_header->get_min_version(ike_header);

	DBG2(DBG_ENC, "parsed a %N %s", exchange_type_names, this->exchange_type,

		 this->is_request ? "request" : "response");

/**

 * Implementation of private_message_t.decrypt_and_verify_payloads.

 */

{

	bool current_payload_was_encrypted = FALSE;

	payload_t *previous_payload = NULL;

				return VERIFY_ERROR;

			}

			/* decrypt */

			DBG2(DBG_ENC, "verify signature of encryption payload");

			status = encryption_payload->verify_signature(encryption_payload,

										this->packet->get_data(this->packet));

			}

			else

			{

			}

			/* is the current paylad the first in the message? */

			if (previous_payload == NULL)

			{

				this->first_payload = current_payload_type;

			}

			else

			{

			}

			/* all encrypted payloads are added to the payload list */

			while (encryption_payload->get_payload_count(encryption_payload) > 0)

			{

			}

			/* encryption payload is processed, payloads are moved. Destroy it. */

			encryption_payload->destroy(encryption_payload);

		}

		{

			/* get the ruleset for found payload */

			status = get_payload_rule(this, current_payload_type, &payload_rule);

				return VERIFY_ERROR;

			}

			if (payload_rule->encrypted != current_payload_was_encrypted)

			{

				DBG1(DBG_ENC, "payload type %N should be %s!",

					 payload_type_names, current_payload_type,

					 (payload_rule->encrypted) ? "encrypted" : "not encrypted");

/**

 * Implementation of message_t.parse_body.

 */

{

	status_t status = SUCCESS;

	payload_type_t current_payload_type;

			 payload_type_names, current_payload_type);

		/* parse current payload */

		if (status != SUCCESS)

		{

			DBG1(DBG_ENC, "payload type %N could not be parsed",

			 payload_type_names, current_payload_type);

		this->payloads->insert_last(this->payloads,current_payload);

		if (current_payload_type == ENCRYPTED)

		{

			DBG2(DBG_ENC, "%N payload found. Stop parsing",