Update libsrtp to version 2.0

test/rtpw.c

 /*
  * rtpw.c
  *
  * rtp word sender/receiver
  *
  * David A. McGrew
  * Cisco Systems, Inc.
  *
  * This app is a simple RTP application intended only for testing
  * libsrtp.  It reads one word at a time from /usr/dict/words (or
@@ skipping 37 matching lines @@
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  * OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  */
 
 
 #ifdef HAVE_CONFIG_H
     #include <config.h>
 #endif
 
-#include "datatypes.h"
 #include "getopt_s.h"       /* for local getopt()  */
 
 #include <stdio.h>          /* for printf, fprintf */
 #include <stdlib.h>         /* for atoi()          */
 #include <errno.h>
 #include <signal.h>         /* for signal()        */
 
 #include <string.h>         /* for strncpy()       */
 #include <time.h>           /* for usleep()        */
 
@@ skipping 12 matching lines @@
 # include <winsock2.h>
 # include <ws2tcpip.h>
 # define RTPW_USE_WINSOCK2      1
 #endif
 #ifdef HAVE_ARPA_INET_H
 # include <arpa/inet.h>
 #endif
 
 #include "srtp.h"           
 #include "rtp.h"
-#include "crypto_kernel.h"
+#include "util.h"
 
 #ifdef RTPW_USE_WINSOCK2
 # define DICT_FILE        "words.txt"
 #else
 # define DICT_FILE        "/usr/share/dict/words"
 #endif
 #define USEC_RATE        (5e5)
 #define MAX_WORD_LEN     128  
 #define ADDR_IS_MULTICAST(a) IN_MULTICAST(htonl(a))
 #define MAX_KEY_LEN      96
@@ skipping 48 matching lines @@
   FILE *dict;
   char word[MAX_WORD_LEN];
   int sock, ret;
   struct in_addr rcvr_addr;
   struct sockaddr_in name;
   struct ip_mreq mreq;
 #if BEW
   struct sockaddr_in local;
 #endif 
   program_type prog_type = unknown;
-  sec_serv_t sec_servs = sec_serv_none;
+  srtp_sec_serv_t sec_servs = sec_serv_none;
   unsigned char ttl = 5;
   int c;
   int key_size = 128;
   int tag_size = 8;
   int gcm_on = 0;
   char *input_key = NULL;
   int b64_input = 0;
   char *address = NULL;
   char key[MAX_KEY_LEN];
   unsigned short port = 0;
   rtp_sender_t snd;
   srtp_policy_t policy;
-  err_status_t status;
+  srtp_err_status_t status;
   int len;
   int expected_len;
   int do_list_mods = 0;
   uint32_t ssrc = 0xdeadbeef; /* ssrc value hardcoded for now */
 #ifdef RTPW_USE_WINSOCK2
   WORD wVersionRequested = MAKEWORD(2, 0);
   WSADATA wsaData;
 
   ret = WSAStartup(wVersionRequested, &wsaData);
   if (ret != 0) {
     fprintf(stderr, "error: WSAStartup() failed: %d\n", ret);
     exit(1);
   }
 #endif
 
+  memset(&policy, 0x0, sizeof(srtp_policy_t));
+
   printf("Using %s [0x%x]\n", srtp_get_version_string(), srtp_get_version());
 
   if (setup_signal_handler(argv[0]) != 0) {
     exit(1);
   }
 
   /* initialize srtp library */
   status = srtp_init();
   if (status) {
     printf("error: srtp initialization failed with error code %d\n", status);
@@ skipping 35 matching lines @@
       gcm_on = 1;
       sec_servs |= sec_serv_auth;
       break;
     case 'r':
       prog_type = receiver;
       break;
     case 's':
       prog_type = sender;
       break;
     case 'd':
-      status = crypto_kernel_set_debug_module(optarg_s, 1);
+      status = srtp_set_debug_module(optarg_s, 1);
       if (status) {
         printf("error: set debug module (%s) failed\n", optarg_s);
         exit(1);
       }
       break;
     case 'l':
       do_list_mods = 1;
       break;
     default:
       usage(argv[0]);
     }
   }
 
   if (prog_type == unknown) {
     if (do_list_mods) {
-      status = crypto_kernel_list_debug_modules();
+      status = srtp_list_debug_modules();
       if (status) {
         printf("error: list of debug modules failed\n");
         exit(1);
       }
       return 0;
     } else {
       printf("error: neither sender [-s] nor receiver [-r] specified\n");
       usage(argv[0]);
     }
   }
@@ skipping 78 matching lines @@
   printf("security services: ");
   if (sec_servs & sec_serv_conf)
     printf("confidentiality ");
   if (sec_servs & sec_serv_auth)
     printf("message authentication");
   if (sec_servs == sec_serv_none)
     printf("none");
   printf("\n");
   
   /* set up the srtp policy and master key */    
-  memset(&policy, 0, sizeof(policy));
   if (sec_servs) {
     /* 
      * create policy structure, using the default mechanisms but 
      * with only the security services requested on the command line,
      * using the right SSRC value
      */
     switch (sec_servs) {
     case sec_serv_conf_and_auth:
       if (gcm_on) {
 #ifdef OPENSSL
         switch (key_size) {
         case 128:
-          crypto_policy_set_aes_gcm_128_8_auth(&policy.rtp);
-          crypto_policy_set_aes_gcm_128_8_auth(&policy.rtcp);
+          srtp_crypto_policy_set_aes_gcm_128_8_auth(&policy.rtp);
+          srtp_crypto_policy_set_aes_gcm_128_8_auth(&policy.rtcp);
           break;
         case 256:
-          crypto_policy_set_aes_gcm_256_8_auth(&policy.rtp);
-          crypto_policy_set_aes_gcm_256_8_auth(&policy.rtcp);
+          srtp_crypto_policy_set_aes_gcm_256_8_auth(&policy.rtp);
+          srtp_crypto_policy_set_aes_gcm_256_8_auth(&policy.rtcp);
           break;
         }
 #else
         printf("error: GCM mode only supported when using the OpenSSL crypto engine.\n");
         return 0;
 #endif
       } else {
         switch (key_size) {
         case 128:
-          crypto_policy_set_rtp_default(&policy.rtp);
-          crypto_policy_set_rtcp_default(&policy.rtcp);
+          srtp_crypto_policy_set_rtp_default(&policy.rtp);
+          srtp_crypto_policy_set_rtcp_default(&policy.rtcp);
           break;
         case 256:
-          crypto_policy_set_aes_cm_256_hmac_sha1_80(&policy.rtp);
-          crypto_policy_set_rtcp_default(&policy.rtcp);
+          srtp_crypto_policy_set_aes_cm_256_hmac_sha1_80(&policy.rtp);
+          srtp_crypto_policy_set_rtcp_default(&policy.rtcp);
           break;
         }
       }
       break;
     case sec_serv_conf:
       if (gcm_on) {
           printf("error: GCM mode must always be used with auth enabled\n");
           return -1;
       } else {
         switch (key_size) {
         case 128:
-          crypto_policy_set_aes_cm_128_null_auth(&policy.rtp);
-          crypto_policy_set_rtcp_default(&policy.rtcp);      
+          srtp_crypto_policy_set_aes_cm_128_null_auth(&policy.rtp);
+          srtp_crypto_policy_set_rtcp_default(&policy.rtcp);      
           break;
         case 256:
-          crypto_policy_set_aes_cm_256_null_auth(&policy.rtp);
-          crypto_policy_set_rtcp_default(&policy.rtcp);      
+          srtp_crypto_policy_set_aes_cm_256_null_auth(&policy.rtp);
+          srtp_crypto_policy_set_rtcp_default(&policy.rtcp);      
           break;
         }
       }
       break;
     case sec_serv_auth:
       if (gcm_on) {
 #ifdef OPENSSL
         switch (key_size) {
         case 128:
-          crypto_policy_set_aes_gcm_128_8_only_auth(&policy.rtp);
-          crypto_policy_set_aes_gcm_128_8_only_auth(&policy.rtcp);
+          srtp_crypto_policy_set_aes_gcm_128_8_only_auth(&policy.rtp);
+          srtp_crypto_policy_set_aes_gcm_128_8_only_auth(&policy.rtcp);
           break;
         case 256:
-          crypto_policy_set_aes_gcm_256_8_only_auth(&policy.rtp);
-          crypto_policy_set_aes_gcm_256_8_only_auth(&policy.rtcp);
+          srtp_crypto_policy_set_aes_gcm_256_8_only_auth(&policy.rtp);
+          srtp_crypto_policy_set_aes_gcm_256_8_only_auth(&policy.rtcp);
           break;
         }
 #else
         printf("error: GCM mode only supported when using the OpenSSL crypto engine.\n");
         return 0;
 #endif
       } else {
-        crypto_policy_set_null_cipher_hmac_sha1_80(&policy.rtp);
-        crypto_policy_set_rtcp_default(&policy.rtcp);
+        srtp_crypto_policy_set_null_cipher_hmac_sha1_80(&policy.rtp);
+        srtp_crypto_policy_set_rtcp_default(&policy.rtcp);
       }
       break;
     default:
       printf("error: unknown security service requested\n");
       return -1;
     } 
     policy.ssrc.type  = ssrc_specific;
     policy.ssrc.value = ssrc;
     policy.key  = (uint8_t *) key;
     policy.ekt  = NULL;
@@ skipping 44 matching lines @@
   } else {
     /*
      * we're not providing security services, so set the policy to the
      * null policy
      *
      * Note that this policy does not conform to the SRTP
      * specification, since RTCP authentication is required.  However,
      * the effect of this policy is to turn off SRTP, so that this
      * application is now a vanilla-flavored RTP application.
      */
+    srtp_crypto_policy_set_null_cipher_hmac_null(&policy.rtp);
+    srtp_crypto_policy_set_null_cipher_hmac_null(&policy.rtcp);
     policy.key                 = (uint8_t *)key;
     policy.ssrc.type           = ssrc_specific;
     policy.ssrc.value          = ssrc;
-    policy.rtp.cipher_type     = NULL_CIPHER;
-    policy.rtp.cipher_key_len  = 0; 
-    policy.rtp.auth_type       = NULL_AUTH;
-    policy.rtp.auth_key_len    = 0;
-    policy.rtp.auth_tag_len    = 0;
-    policy.rtp.sec_serv        = sec_serv_none;   
-    policy.rtcp.cipher_type    = NULL_CIPHER;
-    policy.rtcp.cipher_key_len = 0; 
-    policy.rtcp.auth_type      = NULL_AUTH;
-    policy.rtcp.auth_key_len   = 0;
-    policy.rtcp.auth_tag_len   = 0;
-    policy.rtcp.sec_serv       = sec_serv_none;   
     policy.window_size         = 0;
     policy.allow_repeat_tx     = 0;
     policy.ekt                 = NULL;
     policy.next                = NULL;
   }
 
   if (prog_type == sender) {
 
 #if BEW
     /* bind to local socket (to match crypto policy, if need be) */
@@ skipping 181 matching lines @@
   }
 #else
   if (signal(SIGTERM, handle_signal) == SIG_ERR) {
     fprintf(stderr, "%s: error setting up signal handler", name);
     perror("");
     return -1;
   }
 #endif
   return 0;
 }