Codebase list libnice / 2354556
stun tests: Fix a bunch of issues found by more aggressive GCC warnings Olivier Crête 10 years ago
4 changed file(s) with 67 addition(s) and 62 deletion(s). Raw diff Collapse all Expand all
+24
-21
stun/tests/test-conncheck.c less more
6969 struct sockaddr_in ip4;
7070 uint8_t req_buf[STUN_MAX_MESSAGE_SIZE];
7171 uint8_t resp_buf[STUN_MAX_MESSAGE_SIZE];
72 const uint64_t tie = 0x8000000000000000LL;
72 const const uint64_t tie = 0x8000000000000000LL;
7373 StunMessageReturn val;
7474 StunUsageIceReturn val2;
7575 size_t len;
7676 size_t rlen;
77 static char username[] = "L:R", ufrag[] = "L", pass[] = "secret";
77 static char username[] = "L:R";
78 static uint8_t ufrag[] = "L", pass[] = "secret";
79 size_t ufrag_len = strlen ((char*) ufrag);
80 size_t pass_len = strlen ((char*) pass);
7881 int code;
79 uint16_t alen;
8082 bool control = false;
8183 StunAgent agent;
8284 StunMessage req;
8385 StunMessage resp;
8486 StunDefaultValidaterData validater_data[] = {
85 {ufrag, strlen (ufrag), pass, strlen (pass)},
86 {username, strlen (username), pass, strlen (pass)},
87 {ufrag, ufrag_len, pass, pass_len},
88 {(uint8_t *) username, strlen (username), pass, pass_len},
8789 {NULL, 0, NULL, 0}};
8890 StunValidationStatus valid;
8991
118120 assert (stun_agent_init_request (&agent, &req, req_buf, sizeof(req_buf), 0x666));
119121 val = stun_message_append_string (&req, STUN_ATTRIBUTE_USERNAME, username);
120122 assert (val == STUN_MESSAGE_RETURN_SUCCESS);
121 rlen = stun_agent_finish_message (&agent, &req, pass, strlen (pass));
123 rlen = stun_agent_finish_message (&agent, &req, pass, pass_len);
122124 assert (rlen > 0);
123125
124126 len = sizeof (resp_buf);
134136 assert (val == STUN_MESSAGE_RETURN_SUCCESS);
135137 val = stun_message_append_string (&req, STUN_ATTRIBUTE_USERNAME, username);
136138 assert (val == STUN_MESSAGE_RETURN_SUCCESS);
137 rlen = stun_agent_finish_message (&agent, &req, pass, strlen (pass));
139 rlen = stun_agent_finish_message (&agent, &req, pass, pass_len);
138140 assert (rlen > 0);
139141
140142 valid = stun_agent_validate (&agent, &req, req_buf, rlen,
154156
155157 /* No username */
156158 assert (stun_agent_init_request (&agent, &req, req_buf, sizeof(req_buf), STUN_BINDING));
157 rlen = stun_agent_finish_message (&agent, &req, pass, strlen (pass));
159 rlen = stun_agent_finish_message (&agent, &req, pass, pass_len);
158160 assert (rlen > 0);
159161
160162 valid = stun_agent_validate (&agent, &req, req_buf, rlen,
170172 assert (val == STUN_MESSAGE_RETURN_SUCCESS);
171173 val = stun_message_append_flag (&req, STUN_ATTRIBUTE_USE_CANDIDATE);
172174 assert (val == STUN_MESSAGE_RETURN_SUCCESS);
173 val = stun_message_append_string (&req, STUN_ATTRIBUTE_USERNAME, ufrag);
174 assert (val == STUN_MESSAGE_RETURN_SUCCESS);
175 rlen = stun_agent_finish_message (&agent, &req, pass, strlen (pass));
176 assert (rlen > 0);
177
178 len = sizeof (resp_buf);
179 val2 = stun_usage_ice_conncheck_create_reply (&agent, &req,
180 &resp, resp_buf, &len, (struct sockaddr *)&ip4,
181 sizeof (ip4), &control, tie, STUN_USAGE_ICE_COMPATIBILITY_RFC5245);
182 assert (val == STUN_USAGE_ICE_RETURN_SUCCESS);
175 val = stun_message_append_string (&req, STUN_ATTRIBUTE_USERNAME,
176 (char*) ufrag);
177 assert (val == STUN_MESSAGE_RETURN_SUCCESS);
178 rlen = stun_agent_finish_message (&agent, &req, pass, pass_len);
179 assert (rlen > 0);
180
181 len = sizeof (resp_buf);
182 val2 = stun_usage_ice_conncheck_create_reply (&agent, &req,
183 &resp, resp_buf, &len, (struct sockaddr *)&ip4,
184 sizeof (ip4), &control, tie, STUN_USAGE_ICE_COMPATIBILITY_RFC5245);
185 assert (val2 == STUN_USAGE_ICE_RETURN_SUCCESS);
183186 assert (len > 0);
184187 assert (stun_agent_validate (&agent, &resp, resp_buf, len,
185188 stun_agent_default_validater, validater_data) == STUN_VALIDATION_SUCCESS);
191194 assert (stun_agent_init_request (&agent, &req, req_buf, sizeof(req_buf), STUN_BINDING));
192195 val = stun_message_append_string (&req, STUN_ATTRIBUTE_USERNAME, ufrag);
193196 assert (val == STUN_MESSAGE_RETURN_SUCCESS);
194 rlen = stun_agent_finish_message (&agent, &req, pass, strlen (pass));
197 rlen = stun_agent_finish_message (&agent, &req, pass, pass_len);
195198 assert (rlen > 0);
196199
197200 ip4.sin_family = AF_UNSPEC;
210213 assert (val == STUN_MESSAGE_RETURN_SUCCESS);
211214 val = stun_message_append_string (&req, STUN_ATTRIBUTE_USERNAME, ufrag);
212215 assert (val == STUN_MESSAGE_RETURN_SUCCESS);
213 rlen = stun_agent_finish_message (&agent, &req, pass, strlen (pass));
216 rlen = stun_agent_finish_message (&agent, &req, pass, pass_len);
214217 assert (rlen > 0);
215218
216219
232235 assert (val == STUN_MESSAGE_RETURN_SUCCESS);
233236 val = stun_message_append_string (&req, STUN_ATTRIBUTE_USERNAME, ufrag);
234237 assert (val == STUN_MESSAGE_RETURN_SUCCESS);
235 rlen = stun_agent_finish_message (&agent, &req, pass, strlen (pass));
238 rlen = stun_agent_finish_message (&agent, &req, pass, pass_len);
236239 assert (rlen > 0);
237240
238241 len = sizeof (resp_buf);
+11
-11
stun/tests/test-format.c less more
6565 exit (1);
6666 }
6767
68 static const char usr[] = "admin";
69 static const char pwd[] = "s3kr3t";
70
71 bool dynamic_check_validater (StunAgent *agent,
68 static const uint8_t usr[] = "admin";
69 static const uint8_t pwd[] = "s3kr3t";
70
71 static bool dynamic_check_validater (StunAgent *agent,
7272 StunMessage *message, uint8_t *username, uint16_t username_len,
7373 uint8_t **password, size_t *password_len, void *user_data)
7474 {
7575
76 if (username_len != strlen (usr) ||
77 memcmp (username, usr, strlen (usr)) != 0)
76 if (username_len != strlen ((char *) usr) ||
77 memcmp (username, usr, strlen ((char *) usr)) != 0)
7878 fatal ("vector test : Validater received wrong username!");
7979
8080 *password = (uint8_t *) pwd;
81 *password_len = strlen (pwd);
81 *password_len = strlen ((char *) pwd);
8282
8383
8484 return true;
116116 if (stun_message_find (&msg2, STUN_ATTRIBUTE_MESSAGE_INTEGRITY, &plen) != NULL)
117117 fatal ("Missing HMAC test failed");
118118
119 stun_message_append_string (&msg2, STUN_ATTRIBUTE_USERNAME, usr);
120
121 len = stun_agent_finish_message (agent, &msg2, pwd, strlen (pwd));
119 stun_message_append_string (&msg2, STUN_ATTRIBUTE_USERNAME, (char *) usr);
120
121 len = stun_agent_finish_message (agent, &msg2, pwd, strlen ((char *) pwd));
122122
123123 if (len <= 0)
124124 fatal ("Cannot finish message with short-term creds");
249249 len = sizeof (msg);
250250 if (stun_agent_finish_message (&agent, &msg, NULL, 0) != 0)
251251 fatal ("Fingerprint overflow test failed");
252 if (stun_agent_finish_message (&agent, &msg, pwd, strlen (pwd)) != 0)
252 if (stun_agent_finish_message (&agent, &msg, pwd, strlen ((char *) pwd)) != 0)
253253 fatal ("Message integrity overflow test failed");
254254
255255 /* Address attributes tests */
+16
-15
stun/tests/test-hmac.c less more
4444 #include <stdlib.h>
4545 #include <assert.h>
4646
47 void print_bytes (uint8_t *bytes, int len)
47 static void print_bytes (const uint8_t *bytes, int len)
4848 {
4949 int i;
5050
5454 printf ("\n");
5555 }
5656
57 void test_sha1 (uint8_t *str, uint8_t *expected) {
57 static void test_sha1 (const uint8_t *str, const uint8_t *expected) {
5858 SHA1_CTX ctx;
5959 uint8_t sha1[20];
6060
6161 SHA1Init(&ctx);
62 SHA1Update(&ctx, str, strlen (str));
62 SHA1Update(&ctx, str, strlen ((char *) str));
6363 SHA1Final(sha1, &ctx);
6464
6565 printf ("SHA1 of '%s' : ", str);
7272
7373 }
7474
75 void test_hmac (uint8_t *key, uint8_t *str, uint8_t *expected) {
75 static void test_hmac (const uint8_t *key, const uint8_t *str,
76 const uint8_t *expected) {
7677 uint8_t hmac[20];
7778
78 hmac_sha1(key, strlen (key), str, strlen (str), hmac);
79 hmac_sha1(key, strlen ((char *) key), str, strlen ((char *) str), hmac);
7980 printf ("HMAC of '%s' with key '%s' is : ", str, key);
8081 print_bytes (hmac, SHA1_MAC_LEN);
8182 printf ("Expected : ");
8586 exit (1);
8687 }
8788
88 void test_md5 (uint8_t *str, uint8_t *expected) {
89 static void test_md5 (const uint8_t *str, const uint8_t *expected) {
8990 MD5_CTX ctx;
9091 uint8_t md5[20];
91 int i;
9292
9393 MD5Init(&ctx);
94 MD5Update(&ctx, str, strlen (str));
94 MD5Update(&ctx, str, strlen ((char *) str));
9595 MD5Final(md5, &ctx);
9696
9797 printf ("MD5 of '%s' : 0x", str);
127127 0xaa, 0xe1, 0x16, 0xd3,
128128 0x87, 0x6c, 0x66, 0x4a};
129129
130 test_hmac ("hello", "world", hello_world_hmac);
130 test_hmac ((const uint8_t *) "hello", (const uint8_t*) "world",
131 hello_world_hmac);
131132
132 test_sha1 ("abc", abc_sha1);
133 test_md5 ("abc", abc_md5);
133 test_sha1 ((const uint8_t *) "abc", abc_sha1);
134 test_md5 ((const uint8_t *) "abc", abc_md5);
134135
135 test_sha1 ("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
136 abcd_etc_sha1);
137 test_md5 ("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
138 abcd_etc_md5);
136 test_sha1 ((const uint8_t *)
137 "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", abcd_etc_sha1);
138 test_md5 ((const uint8_t *)
139 "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", abcd_etc_md5);
139140
140141 return 0;
141142 }
+16
-15
stun/tests/test-parse.c less more
284284 }
285285
286286
287 bool test_attribute_validater (StunAgent *agent,
287 static bool test_attribute_validater (StunAgent *agent,
288288 StunMessage *message, uint8_t *username, uint16_t username_len,
289289 uint8_t **password, size_t *password_len, void *user_data)
290290 {
291 char *pwd = (char *) user_data;
291 uint8_t *pwd = user_data;
292292
293293 if (username_len != 4 ||
294294 memcmp (username, "ABCD", 4) != 0)
295295 return false;
296296
297297 *password = pwd;
298 *password_len = strlen (pwd);
298 *password_len = strlen ((char *) pwd);
299299
300300 return true;
301301 }
367367 StunMessage msg;
368368 uint16_t known_attributes[] = {STUN_ATTRIBUTE_MESSAGE_INTEGRITY, STUN_ATTRIBUTE_USERNAME, 0};
369369
370 printf ("Attribute test message length: %lu\n", sizeof (acme));
370 printf ("Attribute test message length: %zd\n", sizeof (acme));
371371
372372 stun_agent_init (&agent, known_attributes,
373373 STUN_COMPATIBILITY_RFC5389, STUN_AGENT_USAGE_SHORT_TERM_CREDENTIALS);
377377 fatal ("Unauthorized validation failed");
378378
379379 if (stun_agent_validate (&agent, &msg, acme, sizeof(acme),
380 test_attribute_validater, "bad__guy") != STUN_VALIDATION_UNAUTHORIZED)
380 test_attribute_validater, (void *) "bad__guy") != STUN_VALIDATION_UNAUTHORIZED)
381381 fatal ("invalid password validation failed");
382382
383383 if (stun_agent_validate (&agent, &msg, acme, sizeof(acme),
384 test_attribute_validater, "good_guy") != STUN_VALIDATION_SUCCESS)
384 test_attribute_validater, (void *) "good_guy") != STUN_VALIDATION_SUCCESS)
385385 fatal ("good password validation failed");
386386
387387 if (stun_message_has_attribute (&msg, 0xff00))
450450 }
451451
452452 static const char vector_username[] = "evtj:h6vY";
453 static const char vector_password[] = "VOkJxbRl1RmTxUk/WvJxBt";
454
455 bool test_vector_validater (StunAgent *agent,
453 static uint8_t vector_password[] = "VOkJxbRl1RmTxUk/WvJxBt";
454
455 static bool test_vector_validater (StunAgent *agent,
456456 StunMessage *message, uint8_t *username, uint16_t username_len,
457457 uint8_t **password, size_t *password_len, void *user_data)
458458 {
465465 memcmp (username, vector_username, strlen (vector_username)) != 0)
466466 fatal ("vector test : Validater received wrong username!");
467467
468 *password = (uint8_t *) vector_password;
469 *password_len = strlen (vector_password);
468 *password = vector_password;
469 *password_len = strlen ((char *) vector_password);
470470
471471
472472 return true;
634634 if (stun_message_length (&msg) != sizeof(req) - 32)
635635 fatal ("vector test: removing attributes failed");
636636
637 stun_agent_finish_message (&agent, &msg, vector_password, strlen (vector_password));
637 stun_agent_finish_message (&agent, &msg, vector_password,
638 strlen ((char *) vector_password));
638639
639640 if (stun_message_length (&msg) != stun_message_length (&msg2) ||
640641 memcmp (req, req2, sizeof(req)) != 0)
709710 puts ("Testing long term credentials hash algorithm...");
710711
711712
712 stun_hash_creds ("realm", strlen ("realm"),
713 "user", strlen ("user"),
714 "pass", strlen ("pass"), md5);
713 stun_hash_creds ((uint8_t *) "realm", strlen ("realm"),
714 (uint8_t *) "user", strlen ("user"),
715 (uint8_t *) "pass", strlen ("pass"), md5);
715716
716717 stun_debug ("key for user:realm:pass is : ");
717718 stun_debug_bytes (md5, 16);