Spelling fixes

* accumulating
* acquire
* alignment
* appropriate
* argument
* assign
* attribute
* authenticate
* authentication
* authenticator
* authority
* auxiliary
* brackets
* callback
* camellia
* can't
* cancelability
* certificate
* choinyambuu
* chunk
* collector
* collision
* communicating
* compares
* compatibility
* compressed
* confidentiality
* configuration
* connection
* consistency
* constraint
* construction
* constructor
* database
* decapsulated
* declaration
* decrypt
* derivative
* destination
* destroyed
* details
* devised
* dynamic
* ecapsulation
* encoded
* encoding
* encrypted
* enforcing
* enumerator
* establishment
* excluded
* exclusively
* exited
* expecting
* expire
* extension
* filter
* firewall
* foundation
* fulfillment
* gateways
* hashing
* hashtable
* heartbeats
* identifier
* identifiers
* identities
* identity
* implementers
* indicating
* initialize
* initiate
* initiation
* initiator
* inner
* instantiate
* legitimate
* libraries
* libstrongswan
* logger
* malloc
* manager
* manually
* measurement
* mechanism
* message
* network
* nonexistent
* object
* occurrence
* optional
* outgoing
* packages
* packets
* padding
* particular
* passphrase
* payload
* periodically
* policies
* possible
* previously
* priority
* proposal
* protocol
* provide
* provider
* pseudo
* pseudonym
* public
* qualifier
* quantum
* quintuplets
* reached
* reading
* recommendation to
* recommendation
* recursive
* reestablish
* referencing
* registered
* rekeying
* reliable
* replacing
* representing
* represents
* request
* request
* resolver
* result
* resulting
* resynchronization
* retriable
* revocation
* right
* rollback
* rule
* rules
* runtime
* scenario
* scheduled
* security
* segment
* service
* setting
* signature
* specific
* specified
* speed
* started
* steffen
* strongswan
* subjectaltname
* supported
* threadsafe
* traffic
* tremendously
* treshold
* unique
* uniqueness
* unknown
* until
* upper
* using
* validator
* verification
* version
* version
* warrior

Closes strongswan/strongswan#164.

src/libcharon/encoding/message.c

@@ -78,9 +78,9 @@ typedef struct {
 	/* Payload type */
 	 payload_type_t type;
 	/* Minimal occurrence of this payload. */
-	size_t min_occurence;
+	size_t min_occurrence;
 	/* Max occurrence of this payload. */
-	size_t max_occurence;
+	size_t max_occurrence;
 	/* TRUE if payload must be encrypted */
 	bool encrypted;
 	/* If payload occurs, the message rule is fulfilled */
@@ -1653,7 +1653,7 @@ static ike_header_t *create_header(private_message_t *this)
 /**
  * Generates the message, if needed, wraps the payloads in an encrypted payload.
  *
- * The generator and the possible enrypted payload are returned.  The latter
+ * The generator and the possible encrypted payload are returned.  The latter
  * is not yet encrypted (but the transform is set).  It is also not added to
  * the payload list (so unless there are unencrypted payloads that list will
  * be empty afterwards).
@@ -2600,11 +2600,11 @@ static status_t verify(private_message_t *this)
 				found++;
 				DBG2(DBG_ENC, "found payload of type %N",
 					 payload_type_names, type);
-				if (found > rule->max_occurence)
+				if (found > rule->max_occurrence)
 				{
 					DBG1(DBG_ENC, "payload of type %N more than %d times (%d) "
 						 "occurred in current message", payload_type_names,
-						 type, rule->max_occurence, found);
+						 type, rule->max_occurrence, found);
 					enumerator->destroy(enumerator);
 					return VERIFY_ERROR;
 				}
@@ -2612,10 +2612,10 @@ static status_t verify(private_message_t *this)
 		}
 		enumerator->destroy(enumerator);
 
-		if (!complete && found < rule->min_occurence)
+		if (!complete && found < rule->min_occurrence)
 		{
 			DBG1(DBG_ENC, "payload of type %N not occurred %d times (%d)",
-				 payload_type_names, rule->type, rule->min_occurence, found);
+				 payload_type_names, rule->type, rule->min_occurrence, found);
 			return VERIFY_ERROR;
 		}
 		if (found && rule->sufficient)