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/libstrongswan/tests/suites/test_auth_cfg.c

@@ -62,7 +62,7 @@ static void check_sig_constraints(auth_cfg_t *cfg, auth_rule_t type,
 	ck_assert(!expected[i]);
 }
 
-START_TEST(test_sig_contraints)
+START_TEST(test_sig_constraints)
 {
 	auth_cfg_t *cfg;
 	signature_scheme_t none[] = {0};
@@ -84,7 +84,7 @@ START_TEST(test_sig_contraints)
 }
 END_TEST
 
-START_TEST(test_ike_contraints_fallback)
+START_TEST(test_ike_constraints_fallback)
 {
 	auth_cfg_t *cfg;
 
@@ -163,7 +163,7 @@ static void check_sig_constraints_params(auth_cfg_t *cfg, auth_rule_t type,
 	ck_assert(!scheme[i]);
 }
 
-START_TEST(test_sig_contraints_params)
+START_TEST(test_sig_constraints_params)
 {
 	auth_cfg_t *cfg;
 
@@ -187,7 +187,7 @@ struct {
 		{ .pss = { .hash = HASH_SHA256, .mgf1_hash = HASH_SHA256, .salt_len = HASH_SIZE_SHA256, }}, {}}},
 };
 
-START_TEST(test_sig_contraints_rsa_pss)
+START_TEST(test_sig_constraints_rsa_pss)
 {
 	auth_cfg_t *cfg;
 
@@ -210,13 +210,13 @@ Suite *auth_cfg_suite_create()
 	s = suite_create("auth_cfg");
 
 	tc = tcase_create("add_pubkey_constraints");
-	tcase_add_loop_test(tc, test_sig_contraints, 0, countof(sig_constraints_tests));
-	tcase_add_loop_test(tc, test_ike_contraints_fallback, 0, countof(sig_constraints_tests));
+	tcase_add_loop_test(tc, test_sig_constraints, 0, countof(sig_constraints_tests));
+	tcase_add_loop_test(tc, test_ike_constraints_fallback, 0, countof(sig_constraints_tests));
 	suite_add_tcase(s, tc);
 
 	tc = tcase_create("add_pubkey_constraints parameters");
-	tcase_add_loop_test(tc, test_sig_contraints_params, 0, countof(sig_constraints_params_tests));
-	tcase_add_loop_test(tc, test_sig_contraints_rsa_pss, 0, countof(sig_constraints_rsa_pss_tests));
+	tcase_add_loop_test(tc, test_sig_constraints_params, 0, countof(sig_constraints_params_tests));
+	tcase_add_loop_test(tc, test_sig_constraints_rsa_pss, 0, countof(sig_constraints_rsa_pss_tests));
 	suite_add_tcase(s, tc);
 
 	return s;

src/libstrongswan/tests/suites/test_threading.c

@@ -1090,7 +1090,7 @@ END_TEST
 
 static void *cancel_run(void *data)
 {
-	/* default cancellability should be TRUE, so don't change it */
+	/* default cancelability should be TRUE, so don't change it */
 	while (TRUE)
 	{
 		sleep(10);
@@ -1152,7 +1152,7 @@ START_TEST(test_cancel_onoff)
 	}
 	for (i = 0; i < THREADS; i++)
 	{
-		/* wait until thread has cleared its cancellability */
+		/* wait until thread has cleared its cancelability */
 		while (cancellable[i])
 		{
 			sched_yield();
@@ -1172,7 +1172,7 @@ static void *cancel_point_run(void *data)
 	thread_cancelability(FALSE);
 	while (TRUE)
 	{
-		/* implicitly enables cancellability */
+		/* implicitly enables cancelability */
 		thread_cancellation_point();
 	}
 	return NULL;

src/libstrongswan/tests/suites/test_utils.c

@@ -353,7 +353,7 @@ START_TEST(test_strpfx)
 END_TEST
 
 /*******************************************************************************
- * mallac_align/free_align
+ * malloc_align/free_align
  */
 
 START_TEST(test_malloc_align)