Fixed merge, don't know why this didn't happen automatically - maybe a leftover from the svn->git conversion

5 files changed, 342 insertions, 0 deletions

diff --git a/src/libcharon/config/backend_manager.c b/src/libcharon/config/backend_manager.c
index 90ef58563..93635ca15 100644
--- a/src/libcharon/config/backend_manager.c
+++ b/src/libcharon/config/backend_manager.c
@@ -96,6 +96,14 @@ static ike_cfg_match_t get_ike_match(ike_cfg_t *cand, host_t *me, host_t *other)
 		{
 			match += MATCH_ANY;
 		}
+<<<<<<< HEAD
+=======
+		else
+		{
+			me_cand->destroy(me_cand);
+			return MATCH_NONE;
+		}
+>>>>>>> upstream/4.5.1
 		me_cand->destroy(me_cand);
 	}
 	else
@@ -119,6 +127,14 @@ static ike_cfg_match_t get_ike_match(ike_cfg_t *cand, host_t *me, host_t *other)
 		{
 			match += MATCH_ANY;
 		}
+<<<<<<< HEAD
+=======
+		else
+		{
+			other_cand->destroy(other_cand);
+			return MATCH_NONE;
+		}
+>>>>>>> upstream/4.5.1
 		other_cand->destroy(other_cand);
 	}
 	else
@@ -128,11 +144,16 @@ static ike_cfg_match_t get_ike_match(ike_cfg_t *cand, host_t *me, host_t *other)
 	return match;
 }
 
+<<<<<<< HEAD
 /**
  * implements backend_manager_t.get_ike_cfg.
  */
 static ike_cfg_t *get_ike_cfg(private_backend_manager_t *this,
 							  host_t *me, host_t *other)
+=======
+METHOD(backend_manager_t, get_ike_cfg, ike_cfg_t*,
+	private_backend_manager_t *this, host_t *me, host_t *other)
+>>>>>>> upstream/4.5.1
 {
 	ike_cfg_t *current, *found = NULL;
 	enumerator_t *enumerator;
@@ -308,12 +329,18 @@ static void insert_sorted(match_entry_t *entry, linked_list_t *list,
 	}
 }
 
+<<<<<<< HEAD
 /**
  * Implements backend_manager_t.create_peer_cfg_enumerator.
  */
 static enumerator_t *create_peer_cfg_enumerator(private_backend_manager_t *this,
 							host_t *me, host_t *other, identification_t *my_id,
 							identification_t *other_id)
+=======
+METHOD(backend_manager_t, create_peer_cfg_enumerator, enumerator_t*,
+	private_backend_manager_t *this, host_t *me, host_t *other,
+	identification_t *my_id, identification_t *other_id)
+>>>>>>> upstream/4.5.1
 {
 	enumerator_t *enumerator;
 	peer_data_t *data;
@@ -372,10 +399,15 @@ static enumerator_t *create_peer_cfg_enumerator(private_backend_manager_t *this,
 									(void*)peer_enum_filter_destroy);
 }
 
+<<<<<<< HEAD
 /**
  * implements backend_manager_t.get_peer_cfg_by_name.
  */
 static peer_cfg_t *get_peer_cfg_by_name(private_backend_manager_t *this, char *name)
+=======
+METHOD(backend_manager_t, get_peer_cfg_by_name, peer_cfg_t*,
+	private_backend_manager_t *this, char *name)
+>>>>>>> upstream/4.5.1
 {
 	backend_t *backend;
 	peer_cfg_t *config = NULL;
@@ -392,30 +424,45 @@ static peer_cfg_t *get_peer_cfg_by_name(private_backend_manager_t *this, char *n
 	return config;
 }
 
+<<<<<<< HEAD
 /**
  * Implementation of backend_manager_t.remove_backend.
  */
 static void remove_backend(private_backend_manager_t *this, backend_t *backend)
+=======
+METHOD(backend_manager_t, remove_backend, void,
+	private_backend_manager_t *this, backend_t *backend)
+>>>>>>> upstream/4.5.1
 {
 	this->lock->write_lock(this->lock);
 	this->backends->remove(this->backends, backend, NULL);
 	this->lock->unlock(this->lock);
 }
 
+<<<<<<< HEAD
 /**
  * Implementation of backend_manager_t.add_backend.
  */
 static void add_backend(private_backend_manager_t *this, backend_t *backend)
+=======
+METHOD(backend_manager_t, add_backend, void,
+	private_backend_manager_t *this, backend_t *backend)
+>>>>>>> upstream/4.5.1
 {
 	this->lock->write_lock(this->lock);
 	this->backends->insert_last(this->backends, backend);
 	this->lock->unlock(this->lock);
 }
 
+<<<<<<< HEAD
 /**
  * Implementation of backend_manager_t.destroy.
  */
 static void destroy(private_backend_manager_t *this)
+=======
+METHOD(backend_manager_t, destroy, void,
+	private_backend_manager_t *this)
+>>>>>>> upstream/4.5.1
 {
 	this->backends->destroy(this->backends);
 	this->lock->destroy(this->lock);
@@ -424,6 +471,7 @@ static void destroy(private_backend_manager_t *this)
 
 /*
  * Described in header-file
+<<<<<<< HEAD
  */
 backend_manager_t *backend_manager_create()
 {
@@ -438,6 +486,26 @@ backend_manager_t *backend_manager_create()
 
 	this->backends = linked_list_create();
 	this->lock = rwlock_create(RWLOCK_TYPE_DEFAULT);
+=======
+
+ */
+backend_manager_t *backend_manager_create()
+{
+	private_backend_manager_t *this;
+
+	INIT(this,
+		.public = {
+			.get_ike_cfg = _get_ike_cfg,
+			.get_peer_cfg_by_name = _get_peer_cfg_by_name,
+			.create_peer_cfg_enumerator = _create_peer_cfg_enumerator,
+			.add_backend = _add_backend,
+			.remove_backend = _remove_backend,
+			.destroy = _destroy,
+		},
+		.backends = linked_list_create(),
+		.lock = rwlock_create(RWLOCK_TYPE_DEFAULT),
+	);
+>>>>>>> upstream/4.5.1
 
 	return &this->public;
 }
diff --git a/src/libcharon/config/child_cfg.c b/src/libcharon/config/child_cfg.c
index 1cdfd5949..6edceffd6 100644
--- a/src/libcharon/config/child_cfg.c
+++ b/src/libcharon/config/child_cfg.c
@@ -80,6 +80,14 @@ struct private_child_cfg_t {
 	ipsec_mode_t mode;
 
 	/**
+<<<<<<< HEAD
+=======
+	 * action to take to start CHILD_SA
+	 */
+	action_t start_action;
+
+	/**
+>>>>>>> upstream/4.5.1
 	 * action to take on DPD
 	 */
 	action_t dpd_action;
@@ -118,6 +126,15 @@ struct private_child_cfg_t {
 	 * Optional mark to install outbound CHILD_SA with
 	 */
 	mark_t mark_out;
+<<<<<<< HEAD
+=======
+
+	/**
+	 * Traffic Flow Confidentiality padding, if enabled
+	 */
+	u_int32_t tfc;
+
+>>>>>>> upstream/4.5.1
 	/**
 	 * set up IPsec transport SA in MIPv6 proxy mode
 	 */
@@ -129,26 +146,41 @@ struct private_child_cfg_t {
 	bool install_policy;
 };
 
+<<<<<<< HEAD
 /**
  * Implementation of child_cfg_t.get_name.
  */
 static char *get_name(private_child_cfg_t *this)
+=======
+METHOD(child_cfg_t, get_name, char*,
+	private_child_cfg_t *this)
+>>>>>>> upstream/4.5.1
 {
 	return this->name;
 }
 
+<<<<<<< HEAD
 /**
  * Implementation of child_cfg_t.add_proposal.
  */
 static void add_proposal(private_child_cfg_t *this, proposal_t *proposal)
+=======
+METHOD(child_cfg_t, add_proposal, void,
+	private_child_cfg_t *this, proposal_t *proposal)
+>>>>>>> upstream/4.5.1
 {
 	this->proposals->insert_last(this->proposals, proposal);
 }
 
+<<<<<<< HEAD
 /**
  * Implementation of child_cfg_t.get_proposals.
  */
 static linked_list_t* get_proposals(private_child_cfg_t *this, bool strip_dh)
+=======
+METHOD(child_cfg_t, get_proposals, linked_list_t*,
+	private_child_cfg_t *this, bool strip_dh)
+>>>>>>> upstream/4.5.1
 {
 	enumerator_t *enumerator;
 	proposal_t *current;
@@ -169,12 +201,18 @@ static linked_list_t* get_proposals(private_child_cfg_t *this, bool strip_dh)
 	return proposals;
 }
 
+<<<<<<< HEAD
 /**
  * Implementation of child_cfg_t.select_proposal.
  */
 static proposal_t* select_proposal(private_child_cfg_t*this,
 								   linked_list_t *proposals, bool strip_dh,
 								   bool private)
+=======
+METHOD(child_cfg_t, select_proposal, proposal_t*,
+	private_child_cfg_t*this, linked_list_t *proposals, bool strip_dh,
+	bool private)
+>>>>>>> upstream/4.5.1
 {
 	enumerator_t *stored_enum, *supplied_enum;
 	proposal_t *stored, *supplied, *selected = NULL;
@@ -219,11 +257,16 @@ static proposal_t* select_proposal(private_child_cfg_t*this,
 	return selected;
 }
 
+<<<<<<< HEAD
 /**
  * Implementation of child_cfg_t.add_traffic_selector.
  */
 static void add_traffic_selector(private_child_cfg_t *this, bool local,
 								 traffic_selector_t *ts)
+=======
+METHOD(child_cfg_t, add_traffic_selector, void,
+	private_child_cfg_t *this, bool local, traffic_selector_t *ts)
+>>>>>>> upstream/4.5.1
 {
 	if (local)
 	{
@@ -235,12 +278,17 @@ static void add_traffic_selector(private_child_cfg_t *this, bool local,
 	}
 }
 
+<<<<<<< HEAD
 /**
  * Implementation of child_cfg_t.get_traffic_selectors.
  */
 static linked_list_t* get_traffic_selectors(private_child_cfg_t *this, bool local,
 											linked_list_t *supplied,
 											host_t *host)
+=======
+METHOD(child_cfg_t, get_traffic_selectors, linked_list_t*,
+	private_child_cfg_t *this, bool local, linked_list_t *supplied,	host_t *host)
+>>>>>>> upstream/4.5.1
 {
 	enumerator_t *e1, *e2;
 	traffic_selector_t *ts1, *ts2, *selected;
@@ -346,18 +394,28 @@ static linked_list_t* get_traffic_selectors(private_child_cfg_t *this, bool loca
 	return result;
 }
 
+<<<<<<< HEAD
 /**
  * Implementation of child_cfg_t.get_updown.
  */
 static char* get_updown(private_child_cfg_t *this)
+=======
+METHOD(child_cfg_t, get_updown, char*,
+	private_child_cfg_t *this)
+>>>>>>> upstream/4.5.1
 {
 	return this->updown;
 }
 
+<<<<<<< HEAD
 /**
  * Implementation of child_cfg_t.get_hostaccess.
  */
 static bool get_hostaccess(private_child_cfg_t *this)
+=======
+METHOD(child_cfg_t, get_hostaccess, bool,
+	private_child_cfg_t *this)
+>>>>>>> upstream/4.5.1
 {
 	return this->hostaccess;
 }
@@ -378,10 +436,15 @@ static u_int64_t apply_jitter(u_int64_t rekey, u_int64_t jitter)
 }
 #define APPLY_JITTER(l) l.rekey = apply_jitter(l.rekey, l.jitter)
 
+<<<<<<< HEAD
 /**
  * Implementation of child_cfg_t.get_lifetime.
  */
 static lifetime_cfg_t *get_lifetime(private_child_cfg_t *this)
+=======
+METHOD(child_cfg_t, get_lifetime, lifetime_cfg_t*,
+	private_child_cfg_t *this)
+>>>>>>> upstream/4.5.1
 {
 	lifetime_cfg_t *lft = malloc_thing(lifetime_cfg_t);
 	memcpy(lft, &this->lifetime, sizeof(lifetime_cfg_t));
@@ -391,34 +454,60 @@ static lifetime_cfg_t *get_lifetime(private_child_cfg_t *this)
 	return lft;
 }
 
+<<<<<<< HEAD
 /**
  * Implementation of child_cfg_t.get_mode.
  */
 static ipsec_mode_t get_mode(private_child_cfg_t *this)
+=======
+METHOD(child_cfg_t, get_mode, ipsec_mode_t,
+	private_child_cfg_t *this)
+>>>>>>> upstream/4.5.1
 {
 	return this->mode;
 }
 
+<<<<<<< HEAD
 /**
  * Implementation of child_cfg_t.get_dpd_action.
  */
 static action_t get_dpd_action(private_child_cfg_t *this)
+=======
+METHOD(child_cfg_t, get_start_action, action_t,
+	private_child_cfg_t *this)
+{
+	return this->start_action;
+}
+
+METHOD(child_cfg_t, get_dpd_action, action_t,
+	private_child_cfg_t *this)
+>>>>>>> upstream/4.5.1
 {
 	return this->dpd_action;
 }
 
+<<<<<<< HEAD
 /**
  * Implementation of child_cfg_t.get_close_action.
  */
 static action_t get_close_action(private_child_cfg_t *this)
+=======
+METHOD(child_cfg_t, get_close_action, action_t,
+	private_child_cfg_t *this)
+>>>>>>> upstream/4.5.1
 {
 	return this->close_action;
 }
 
+<<<<<<< HEAD
 /**
  * Implementation of child_cfg_t.get_dh_group.
  */
 static diffie_hellman_group_t get_dh_group(private_child_cfg_t *this)
+=======
+METHOD(child_cfg_t, get_dh_group, diffie_hellman_group_t,
+	private_child_cfg_t *this)
+>>>>>>> upstream/4.5.1
 {
 	enumerator_t *enumerator;
 	proposal_t *proposal;
@@ -436,77 +525,128 @@ static diffie_hellman_group_t get_dh_group(private_child_cfg_t *this)
 	return dh_group;
 }
 
+<<<<<<< HEAD
 /**
  * Implementation of child_cfg_t.use_ipcomp.
  */
 static bool use_ipcomp(private_child_cfg_t *this)
+=======
+METHOD(child_cfg_t, use_ipcomp, bool,
+	private_child_cfg_t *this)
+>>>>>>> upstream/4.5.1
 {
 	return this->use_ipcomp;
 }
 
+<<<<<<< HEAD
 /**
  * Implementation of child_cfg_t.get_inactivity.
  */
 static u_int32_t get_inactivity(private_child_cfg_t *this)
+=======
+METHOD(child_cfg_t, get_inactivity, u_int32_t,
+	private_child_cfg_t *this)
+>>>>>>> upstream/4.5.1
 {
 	return this->inactivity;
 }
 
+<<<<<<< HEAD
 /**
  * Implementation of child_cfg_t.get_reqid.
  */
 static u_int32_t get_reqid(private_child_cfg_t *this)
+=======
+METHOD(child_cfg_t, get_reqid, u_int32_t,
+	private_child_cfg_t *this)
+>>>>>>> upstream/4.5.1
 {
 	return this->reqid;
 }
 
+<<<<<<< HEAD
 /**
  * Implementation of child_cfg_t.get_mark.
  */
 static mark_t get_mark(private_child_cfg_t *this, bool inbound)
+=======
+METHOD(child_cfg_t, get_mark, mark_t,
+	private_child_cfg_t *this, bool inbound)
+>>>>>>> upstream/4.5.1
 {
 	return inbound ? this->mark_in : this->mark_out;
 }
 
+<<<<<<< HEAD
 /**
  * Implementation of child_cfg_t.set_mipv6_options.
  */
 static void set_mipv6_options(private_child_cfg_t *this, bool proxy_mode,
 														 bool install_policy)
+=======
+METHOD(child_cfg_t, get_tfc, u_int32_t,
+	private_child_cfg_t *this)
+{
+	return this->tfc;
+}
+
+METHOD(child_cfg_t, set_mipv6_options, void,
+	private_child_cfg_t *this, bool proxy_mode, bool install_policy)
+>>>>>>> upstream/4.5.1
 {
 	this->proxy_mode = proxy_mode;
 	this->install_policy = install_policy;
 }
 
+<<<<<<< HEAD
 /**
  * Implementation of child_cfg_t.use_proxy_mode.
  */
 static bool use_proxy_mode(private_child_cfg_t *this)
+=======
+METHOD(child_cfg_t, use_proxy_mode, bool,
+	private_child_cfg_t *this)
+>>>>>>> upstream/4.5.1
 {
 	return this->proxy_mode;
 }
 
+<<<<<<< HEAD
 /**
  * Implementation of child_cfg_t.install_policy.
  */
 static bool install_policy(private_child_cfg_t *this)
+=======
+METHOD(child_cfg_t, install_policy, bool,
+	private_child_cfg_t *this)
+>>>>>>> upstream/4.5.1
 {
 	return this->install_policy;
 }
 
+<<<<<<< HEAD
 /**
  * Implementation of child_cfg_t.get_ref.
  */
 static child_cfg_t* get_ref(private_child_cfg_t *this)
+=======
+METHOD(child_cfg_t, get_ref, child_cfg_t*,
+	private_child_cfg_t *this)
+>>>>>>> upstream/4.5.1
 {
 	ref_get(&this->refcount);
 	return &this->public;
 }
 
+<<<<<<< HEAD
 /**
  * Implements child_cfg_t.destroy.
  */
 static void destroy(private_child_cfg_t *this)
+=======
+METHOD(child_cfg_t, destroy, void,
+	private_child_cfg_t *this)
+>>>>>>> upstream/4.5.1
 {
 	if (ref_put(&this->refcount))
 	{
@@ -527,6 +667,7 @@ static void destroy(private_child_cfg_t *this)
  */
 child_cfg_t *child_cfg_create(char *name, lifetime_cfg_t *lifetime,
 							  char *updown, bool hostaccess,
+<<<<<<< HEAD
 							  ipsec_mode_t mode, action_t dpd_action,
 							  action_t close_action, bool ipcomp,
 							  u_int32_t inactivity, u_int32_t reqid,
@@ -566,20 +707,78 @@ child_cfg_t *child_cfg_create(char *name, lifetime_cfg_t *lifetime,
 	this->use_ipcomp = ipcomp;
 	this->inactivity = inactivity;
 	this->reqid = reqid;
+=======
+							  ipsec_mode_t mode, action_t start_action,
+							  action_t dpd_action, action_t close_action,
+							  bool ipcomp, u_int32_t inactivity, u_int32_t reqid,
+							  mark_t *mark_in, mark_t *mark_out, u_int32_t tfc)
+{
+	private_child_cfg_t *this;
+
+	INIT(this,
+		.public = {
+			.get_name = _get_name,
+			.add_traffic_selector = _add_traffic_selector,
+			.get_traffic_selectors = _get_traffic_selectors,
+			.add_proposal = _add_proposal,
+			.get_proposals = _get_proposals,
+			.select_proposal = _select_proposal,
+			.get_updown = _get_updown,
+			.get_hostaccess = _get_hostaccess,
+			.get_mode = _get_mode,
+			.get_start_action = _get_start_action,
+			.get_dpd_action = _get_dpd_action,
+			.get_close_action = _get_close_action,
+			.get_lifetime = _get_lifetime,
+			.get_dh_group = _get_dh_group,
+			.set_mipv6_options = _set_mipv6_options,
+			.use_ipcomp = _use_ipcomp,
+			.get_inactivity = _get_inactivity,
+			.get_reqid = _get_reqid,
+			.get_mark = _get_mark,
+			.get_tfc = _get_tfc,
+			.use_proxy_mode = _use_proxy_mode,
+			.install_policy = _install_policy,
+			.get_ref = _get_ref,
+			.destroy = _destroy,
+		},
+		.name = strdup(name),
+		.updown = strdupnull(updown),
+		.hostaccess = hostaccess,
+		.mode = mode,
+		.start_action = start_action,
+		.dpd_action = dpd_action,
+		.close_action = close_action,
+		.use_ipcomp = ipcomp,
+		.inactivity = inactivity,
+		.reqid = reqid,
+		.proxy_mode = FALSE,
+		.install_policy = TRUE,
+		.refcount = 1,
+		.proposals = linked_list_create(),
+		.my_ts = linked_list_create(),
+		.other_ts = linked_list_create(),
+		.tfc = tfc,
+	);
+>>>>>>> upstream/4.5.1
 
 	if (mark_in)
 	{
 		this->mark_in = *mark_in;
 	}
+<<<<<<< HEAD
 	else
 	{
 		this->mark_in.value = 0;
 		this->mark_in.mask  = 0;
 	}
+=======
+>>>>>>> upstream/4.5.1
 	if (mark_out)
 	{
 		this->mark_out = *mark_out;
 	}
+<<<<<<< HEAD
 	else
 	{
 		this->mark_out.value = 0;
@@ -592,6 +791,8 @@ child_cfg_t *child_cfg_create(char *name, lifetime_cfg_t *lifetime,
 	this->proposals = linked_list_create();
 	this->my_ts = linked_list_create();
 	this->other_ts = linked_list_create();
+=======
+>>>>>>> upstream/4.5.1
 	memcpy(&this->lifetime, lifetime, sizeof(lifetime_cfg_t));
 
 	return &this->public;
diff --git a/src/libcharon/config/child_cfg.h b/src/libcharon/config/child_cfg.h
index 1e6fe3fe9..d933b2a04 100644
--- a/src/libcharon/config/child_cfg.h
+++ b/src/libcharon/config/child_cfg.h
@@ -32,14 +32,25 @@ typedef struct child_cfg_t child_cfg_t;
 #include <kernel/kernel_ipsec.h>
 
 /**
+<<<<<<< HEAD
  * Action to take when DPD detected/connection gets closed by peer.
+=======
+ * Action to take when connection is loaded, DPD is detected or
+ * connection gets closed by peer.
+>>>>>>> upstream/4.5.1
  */
 enum action_t {
 	/** No action */
 	ACTION_NONE,
+<<<<<<< HEAD
 	/** Route config to reestablish on demand */
 	ACTION_ROUTE,
 	/** Restart config immediately */
+=======
+	/** Route config to establish or reestablish on demand */
+	ACTION_ROUTE,
+	/** Start or restart config immediately */
+>>>>>>> upstream/4.5.1
 	ACTION_RESTART,
 };
 
@@ -169,6 +180,16 @@ struct child_cfg_t {
 	ipsec_mode_t (*get_mode) (child_cfg_t *this);
 
 	/**
+<<<<<<< HEAD
+=======
+	 * Action to take to start CHILD_SA.
+	 *
+	 * @return				start action
+	 */
+	action_t (*get_start_action) (child_cfg_t *this);
+
+	/**
+>>>>>>> upstream/4.5.1
 	 * Action to take on DPD.
 	 *
 	 * @return				DPD action
@@ -220,6 +241,16 @@ struct child_cfg_t {
 	mark_t (*get_mark)(child_cfg_t *this, bool inbound);
 
 	/**
+<<<<<<< HEAD
+=======
+	 * Get the TFC padding value to use for CHILD_SA.
+	 *
+	 * @return				TFC padding, 0 to disable, -1 for MTU
+	 */
+	u_int32_t (*get_tfc)(child_cfg_t *this);
+
+	/**
+>>>>>>> upstream/4.5.1
 	 * Sets two options needed for Mobile IPv6 interoperability
 	 *
 	 * @param proxy_mode	use IPsec transport proxy mode (default FALSE)
@@ -276,6 +307,10 @@ struct child_cfg_t {
  * @param updown			updown script to execute on up/down event
  * @param hostaccess		TRUE to allow access to the local host
  * @param mode				mode to propose for CHILD_SA, transport, tunnel or BEET
+<<<<<<< HEAD
+=======
+ * @param start_action		start action
+>>>>>>> upstream/4.5.1
  * @param dpd_action		DPD action
  * @param close_action		close action
  * @param ipcomp			use IPComp, if peer supports it
@@ -283,13 +318,24 @@ struct child_cfg_t {
  * @param reqid				specific reqid to use for CHILD_SA, 0 for auto assign
  * @param mark_in			optional inbound mark (can be NULL)
  * @param mark_out			optional outbound mark (can be NULL)
+<<<<<<< HEAD
+=======
+ * @param tfc				TFC padding size, 0 to disable, -1 to pad to PMTU
+>>>>>>> upstream/4.5.1
  * @return					child_cfg_t object
  */
 child_cfg_t *child_cfg_create(char *name, lifetime_cfg_t *lifetime,
 							  char *updown, bool hostaccess,
+<<<<<<< HEAD
 							  ipsec_mode_t mode, action_t dpd_action,
 							  action_t close_action, bool ipcomp,
 							  u_int32_t inactivity, u_int32_t reqid,
 							  mark_t *mark_in, mark_t *mark_out);
+=======
+							  ipsec_mode_t mode, action_t start_action,
+							  action_t dpd_action, action_t close_action,
+							  bool ipcomp, u_int32_t inactivity, u_int32_t reqid,
+							  mark_t *mark_in, mark_t *mark_out, u_int32_t tfc);
+>>>>>>> upstream/4.5.1
 
 #endif /** CHILD_CFG_H_ @}*/
diff --git a/src/libcharon/config/peer_cfg.c b/src/libcharon/config/peer_cfg.c
index 9df14c9ae..2b31eca04 100644
--- a/src/libcharon/config/peer_cfg.c
+++ b/src/libcharon/config/peer_cfg.c
@@ -682,7 +682,11 @@ peer_cfg_t *peer_cfg_create(char *name, u_int ike_version, ike_cfg_t *ike_cfg,
 	this->use_mobike = mobike;
 	this->dpd = dpd;
 	this->virtual_ip = virtual_ip;
+<<<<<<< HEAD
 	this->pool = pool ? strdup(pool) : NULL;
+=======
+	this->pool = strdupnull(pool);
+>>>>>>> upstream/4.5.1
 	this->local_auth = linked_list_create();
 	this->remote_auth = linked_list_create();
 	this->refcount = 1;
diff --git a/src/libcharon/config/proposal.c b/src/libcharon/config/proposal.c
index 5b8294599..aba7feede 100644
--- a/src/libcharon/config/proposal.c
+++ b/src/libcharon/config/proposal.c
@@ -560,6 +560,10 @@ static status_t add_string_algo(private_proposal_t *this, chunk_t alg)
 
 	if (token == NULL)
 	{
+<<<<<<< HEAD
+=======
+		DBG1(DBG_CFG, "algorithm '%.*s' not recognized", alg.len, alg.ptr);
+>>>>>>> upstream/4.5.1
 		return FAILED;
 	}
 
@@ -740,9 +744,16 @@ static void proposal_add_supported_ike(private_proposal_t *this)
 	integrity_algorithm_t integrity;
 	pseudo_random_function_t prf;
 	diffie_hellman_group_t group;
+<<<<<<< HEAD
 
 	enumerator = lib->crypto->create_crypter_enumerator(lib->crypto);
 	while (enumerator->enumerate(enumerator, &encryption))
+=======
+	const char *plugin_name;
+
+	enumerator = lib->crypto->create_crypter_enumerator(lib->crypto);
+	while (enumerator->enumerate(enumerator, &encryption, &plugin_name))
+>>>>>>> upstream/4.5.1
 	{
 		switch (encryption)
 		{
@@ -777,7 +788,11 @@ static void proposal_add_supported_ike(private_proposal_t *this)
 	enumerator->destroy(enumerator);
 
 	enumerator = lib->crypto->create_signer_enumerator(lib->crypto);
+<<<<<<< HEAD
 	while (enumerator->enumerate(enumerator, &integrity))
+=======
+	while (enumerator->enumerate(enumerator, &integrity, &plugin_name))
+>>>>>>> upstream/4.5.1
 	{
 		switch (integrity)
 		{
@@ -796,7 +811,11 @@ static void proposal_add_supported_ike(private_proposal_t *this)
 	enumerator->destroy(enumerator);
 
 	enumerator = lib->crypto->create_prf_enumerator(lib->crypto);
+<<<<<<< HEAD
 	while (enumerator->enumerate(enumerator, &prf))
+=======
+	while (enumerator->enumerate(enumerator, &prf, &plugin_name))
+>>>>>>> upstream/4.5.1
 	{
 		switch (prf)
 		{
@@ -815,7 +834,11 @@ static void proposal_add_supported_ike(private_proposal_t *this)
 	enumerator->destroy(enumerator);
 
 	enumerator = lib->crypto->create_dh_enumerator(lib->crypto);
+<<<<<<< HEAD
 	while (enumerator->enumerate(enumerator, &group))
+=======
+	while (enumerator->enumerate(enumerator, &group, &plugin_name))
+>>>>>>> upstream/4.5.1
 	{
 		switch (group)
 		{