← Back to branch summary

~ubuntu-branches/debian/stretch/libnice/stretch

« back to all changes in this revision

Viewing changes to stun/tests/test-parse.c

  • Committer: Package Import Robot
  • Author(s): Simon McVittie
  • Date: 2014-05-14 12:00:13 UTC
  • mfrom: (1.2.9) (5.1.13 sid)
  • Revision ID: package-import@ubuntu.com-20140514120013-fi5mh9bexrjnwnd8
Tags: 0.1.7-1
http://bugs.debian.org/743232
http://bugs.debian.org/743233
* New upstream release 0.1.6, 0.1.7
  - fixes various compiler warnings that were mistakenly fatal in 0.1.5
    (Closes: #743232, #743233)
  - update symbols file for new API
* Explicitly disable -Werror, even if we package a non-release in future
* Don't run tests during the build. We were ignoring failures already,
  and they sometimes hang until the buildd terminates them.
  Upstream (Olivier Crête) says they are stable enough to be useful
  for developers, but not for integration testing.

Show diffs side-by-side

added added

removed removed

Lines of Context:
stun/tests/test-parse.c
285
285
}
286
286
 
287
287
 
288
 
bool test_attribute_validater (StunAgent *agent,
 
288
static bool test_attribute_validater (StunAgent *agent,
289
289
    StunMessage *message, uint8_t *username, uint16_t username_len,
290
290
    uint8_t **password, size_t *password_len, void *user_data)
291
291
{
292
 
  char *pwd = (char *) user_data;
 
292
  uint8_t *pwd = user_data;
293
293
 
294
294
  if (username_len != 4 ||
295
295
      memcmp (username, "ABCD", 4) != 0)
296
296
    return false;
297
297
 
298
298
  *password = pwd;
299
 
  *password_len = strlen (pwd);
 
299
  *password_len = strlen ((char *) pwd);
300
300
 
301
301
  return true;
302
302
}
356
356
 
357
357
  union
358
358
  {
359
 
    struct sockaddr sa;
 
359
    struct sockaddr_storage st;
360
360
    struct sockaddr_in6 s6;
361
361
  } addr;
362
362
  socklen_t addrlen;
368
368
  StunMessage msg;
369
369
  uint16_t known_attributes[] = {STUN_ATTRIBUTE_MESSAGE_INTEGRITY, STUN_ATTRIBUTE_USERNAME, 0};
370
370
 
371
 
  printf ("Attribute test message length: %lu\n", sizeof (acme));
 
371
  printf ("Attribute test message length: %zd\n", sizeof (acme));
372
372
 
373
373
  stun_agent_init (&agent, known_attributes,
374
374
      STUN_COMPATIBILITY_RFC5389, STUN_AGENT_USAGE_SHORT_TERM_CREDENTIALS);
378
378
    fatal ("Unauthorized validation failed");
379
379
 
380
380
  if (stun_agent_validate (&agent, &msg, acme, sizeof(acme),
381
 
          test_attribute_validater, "bad__guy") != STUN_VALIDATION_UNAUTHORIZED)
 
381
          test_attribute_validater, (void *) "bad__guy") != STUN_VALIDATION_UNAUTHORIZED)
382
382
    fatal ("invalid password validation failed");
383
383
 
384
384
  if (stun_agent_validate (&agent, &msg, acme, sizeof(acme),
385
 
          test_attribute_validater, "good_guy") != STUN_VALIDATION_SUCCESS)
 
385
          test_attribute_validater, (void *) "good_guy") != STUN_VALIDATION_SUCCESS)
386
386
    fatal ("good password validation failed");
387
387
 
388
388
  if (stun_message_has_attribute (&msg, 0xff00))
422
422
    fatal ("String test failed");
423
423
 
424
424
  addrlen = sizeof (addr);
425
 
  if (stun_message_find_addr (&msg, 0xff01, &addr.sa, &addrlen) !=
 
425
  if (stun_message_find_addr (&msg, 0xff01, &addr.st, &addrlen) !=
426
426
      STUN_MESSAGE_RETURN_INVALID)
427
427
    fatal ("Too short addres test failed");
428
428
  addrlen = sizeof (addr);
429
 
  if (stun_message_find_addr (&msg, 0xff02, &addr.sa, &addrlen) !=
 
429
  if (stun_message_find_addr (&msg, 0xff02, &addr.st, &addrlen) !=
430
430
      STUN_MESSAGE_RETURN_UNSUPPORTED_ADDRESS)
431
431
    fatal ("Unknown address family test failed");
432
432
  addrlen = sizeof (addr);
433
 
  if (stun_message_find_addr (&msg, 0xff03, &addr.sa, &addrlen) !=
 
433
  if (stun_message_find_addr (&msg, 0xff03, &addr.st, &addrlen) !=
434
434
      STUN_MESSAGE_RETURN_INVALID)
435
435
    fatal ("Too short IPv6 address test failed");
436
436
  addrlen = sizeof (addr);
437
 
  if (stun_message_find_addr (&msg, 0xff04, &addr.sa, &addrlen) !=
 
437
  if (stun_message_find_addr (&msg, 0xff04, &addr.st, &addrlen) !=
438
438
      STUN_MESSAGE_RETURN_SUCCESS)
439
439
    fatal ("IPv4 address test failed");
440
440
  addrlen = sizeof (addr);
441
 
  if (stun_message_find_addr (&msg, 0xff05, &addr.sa, &addrlen) !=
 
441
  if (stun_message_find_addr (&msg, 0xff05, &addr.st, &addrlen) !=
442
442
      STUN_MESSAGE_RETURN_INVALID)
443
443
    fatal ("Too big IPv4 address test failed");
444
444
  addrlen = sizeof (addr);
445
 
  if (stun_message_find_xor_addr (&msg, 0xff06, &addr.sa, &addrlen) !=
 
445
  if (stun_message_find_xor_addr (&msg, 0xff06, &addr.st, &addrlen) !=
446
446
      STUN_MESSAGE_RETURN_SUCCESS ||
447
447
      memcmp (&addr.s6.sin6_addr, "\x20\x01\x0d\xb8""\xde\xad\xbe\xef"
448
448
                                  "\xde\xfa\xce\xd0""\xfa\xce\xde\xed", 16))
451
451
}
452
452
 
453
453
static const char vector_username[] = "evtj:h6vY";
454
 
static const char vector_password[] = "VOkJxbRl1RmTxUk/WvJxBt";
 
454
static uint8_t vector_password[] = "VOkJxbRl1RmTxUk/WvJxBt";
455
455
 
456
 
bool test_vector_validater (StunAgent *agent,
 
456
static bool test_vector_validater (StunAgent *agent,
457
457
    StunMessage *message, uint8_t *username, uint16_t username_len,
458
458
    uint8_t **password, size_t *password_len, void *user_data)
459
459
{
466
466
      memcmp (username, vector_username, strlen (vector_username)) != 0)
467
467
    fatal ("vector test : Validater received wrong username!");
468
468
 
469
 
  *password = (uint8_t *) vector_password;
470
 
  *password_len = strlen (vector_password);
 
469
  *password = vector_password;
 
470
  *password_len = strlen ((char *) vector_password);
471
471
 
472
472
 
473
473
  return true;
598
598
 
599
599
       0x80, 0x28, 0x00, 0x04, // FINGERPRINT
600
600
       0xec, 0x27, 0xae, 0xb7};
601
 
  struct sockaddr_in ip4;
602
 
  struct sockaddr_in6 ip6;
 
601
  union {
 
602
    struct sockaddr_storage st;
 
603
    struct sockaddr_in ip4;
 
604
    struct sockaddr_in6 ip6;
 
605
  } addr;
603
606
  socklen_t addrlen;
604
607
 
605
608
  StunAgent agent;
616
619
      STUN_AGENT_USAGE_SHORT_TERM_CREDENTIALS |
617
620
      STUN_AGENT_USAGE_USE_FINGERPRINT);
618
621
 
619
 
  memset (&ip4, 0, sizeof (ip4));
620
 
  memset (&ip6, 0, sizeof (ip6));
 
622
  memset (&addr, 0, sizeof (addr));
621
623
 
622
624
  puts ("Checking test vectors...");
623
625
 
635
637
  if (stun_message_length (&msg) != sizeof(req) - 32)
636
638
    fatal ("vector test: removing attributes failed");
637
639
 
638
 
  stun_agent_finish_message (&agent, &msg, vector_password, strlen (vector_password));
 
640
  stun_agent_finish_message (&agent, &msg, vector_password,
 
641
      strlen ((char *) vector_password));
639
642
 
640
643
  if (stun_message_length (&msg) != stun_message_length (&msg2) ||
641
644
      memcmp (req, req2, sizeof(req)) != 0)
649
652
          test_vector_validater, (void *) 0) != STUN_VALIDATION_UNMATCHED_RESPONSE)
650
653
    fatal ("Response ipv4 test vector authentication failed");
651
654
 
652
 
  addrlen = sizeof (ip4);
 
655
  addrlen = sizeof (addr.ip4);
653
656
  if (stun_message_find_xor_addr (&msg, STUN_ATTRIBUTE_XOR_MAPPED_ADDRESS,
654
 
          (struct sockaddr *)&ip4, &addrlen) != STUN_MESSAGE_RETURN_SUCCESS)
 
657
          &addr.st, &addrlen) != STUN_MESSAGE_RETURN_SUCCESS)
655
658
    fatal ("Response test vector IPv4 extraction failed");
656
 
  if (ip4.sin_family != AF_INET)
 
659
  if (addr.ip4.sin_family != AF_INET)
657
660
    fatal ("Response test vector IPv4 family failed");
658
 
  if (ntohl (ip4.sin_addr.s_addr) != 0xC0000201)
 
661
  if (ntohl (addr.ip4.sin_addr.s_addr) != 0xC0000201)
659
662
    fatal ("Response test vector IPv4 address failed");
660
 
  if (ntohs (ip4.sin_port) != 32853)
 
663
  if (ntohs (addr.ip4.sin_port) != 32853)
661
664
    fatal ("Response test vector IPv6 port failed");
662
665
 
663
666
  if (stun_agent_validate (&agent, &msg, req, sizeof(req),
682
685
          test_vector_validater, (void *) 1) != STUN_VALIDATION_SUCCESS)
683
686
    fatal ("Response ipv6 test vector authentication failed");
684
687
 
685
 
  addrlen = sizeof (ip6);
 
688
  addrlen = sizeof (addr.ip6);
686
689
  if (stun_message_find_xor_addr (&msg, STUN_ATTRIBUTE_XOR_MAPPED_ADDRESS,
687
 
          (struct sockaddr *)&ip6, &addrlen) != STUN_MESSAGE_RETURN_SUCCESS)
 
690
          &addr.st, &addrlen) != STUN_MESSAGE_RETURN_SUCCESS)
688
691
    fatal ("Response test vector IPv6 extraction failed");
689
 
  if (ip6.sin6_family != AF_INET6)
 
692
  if (addr.ip6.sin6_family != AF_INET6)
690
693
    fatal ("Response test vector IPv6 family failed");
691
 
  if (memcmp (ip6.sin6_addr.s6_addr, "\x20\x01\x0d\xb8\x12\x34\x56\x78"
 
694
  if (memcmp (addr.ip6.sin6_addr.s6_addr, "\x20\x01\x0d\xb8\x12\x34\x56\x78"
692
695
              "\x00\x11\x22\x33\x44\x55\x66\x77", 16) != 0)
693
696
    fatal ("Response test vector IPv6 address failed");
694
 
  if (ntohs (ip6.sin6_port) != 32853)
 
697
  if (ntohs (addr.ip6.sin6_port) != 32853)
695
698
    fatal ("Response test vector IPv6 port failed");
696
699
 
697
700
 
710
713
  puts ("Testing long term credentials hash algorithm...");
711
714
 
712
715
 
713
 
  stun_hash_creds ("realm", strlen ("realm"),
714
 
      "user",  strlen ("user"),
715
 
      "pass", strlen ("pass"), md5);
 
716
  stun_hash_creds ((uint8_t *) "realm", strlen ("realm"),
 
717
      (uint8_t *) "user",  strlen ("user"),
 
718
      (uint8_t *) "pass", strlen ("pass"), md5);
716
719
 
717
720
  stun_debug ("key for user:realm:pass is : ");
718
721
  stun_debug_bytes (md5, 16);