[svn] / ecrypt / trunk / test / ecrypt-test.c  

svn: ecrypt/trunk/test/ecrypt-test.c

Diff for /ecrypt/trunk/test/ecrypt-test.c between version 78 and 107

version 78, Sun Aug 21 16:11:43 2005 UTC version 107, Fri Sep 16 14:17:22 2005 UTC
Line 85 
Line 85 
 int quiet = 0;  int quiet = 0;
 int test_packet = 1;  int test_packet = 1;
 int test_setup = 1;  int test_setup = 1;
   int test_agility = 1;
 int output_vectors = 0;  int output_vectors = 0;
 int single_key = 0;  
   
 int errors = 0;  int errors = 0;
   
Line 1072 
Line 1072 
   
 /* ------------------------------------------------------------------------- */  /* ------------------------------------------------------------------------- */
   
 #define KEYS_TO_TEST 100  #define PAGESIZE 0x2000
 #define TEST_TARGET 0x1000  
 #define TEST_BLOCKS (TEST_TARGET + ECRYPT_BLOCKLENGTH - 1) / ECRYPT_BLOCKLENGTH  
   
 #define TEST_SPEED(LOOP, TEST)                                                \  void* aligned_malloc(size_t size)
   {
     void* ptr = malloc(size + PAGESIZE);
   
     if (ptr)
       {
         void* aligned = (void*)(((long)ptr + PAGESIZE) & ~(PAGESIZE - 1));
         ((void**)aligned)[-1] = ptr;
   
         return aligned;
       }
     else
       return NULL;
   }
   
   void aligned_free(void* aligned)
   {
     if (aligned)
       {
         void* ptr = ((void**)aligned)[-1];
         free(ptr);
       }
   }
   
   /* ------------------------------------------------------------------------- */
   
   #define BYTES_TO_BLOCKS(b) ((b + ECRYPT_BLOCKLENGTH - 1) / ECRYPT_BLOCKLENGTH)
   
   #undef MAX
   #define MAX(a, b) ((a) > (b) ? (a) : (b))
   
   #define MIN_KEYS_TO_TEST 100
   #define MAX_KEYS_TO_TEST (0x1000000 / sizeof(CTX))
   
   #ifndef ECRYPT_BUFFERLENGTH
   #define ECRYPT_BUFFERLENGTH 0x1000
   #endif
   
   #define SMALL_BUFFER BYTES_TO_BLOCKS(0x100)
   #define FAST_BUFFER BYTES_TO_BLOCKS(ECRYPT_BUFFERLENGTH)
   
   #define TEST_SPEED(max_keys_to_test, LOOP, TEST)                              \
   do {                                                                        \    do {                                                                        \
                                                                               \                                                                                \
     for (keys_to_test = 1; 1; keys_to_test *= 10)                             \      for (keys_to_test = 1; 1; keys_to_test *= 10)                             \
Line 1088 
Line 1127 
         /* And then compute how many tests can be made in 1/10th second */    \          /* And then compute how many tests can be made in 1/10th second */    \
         start = clock();                                                      \          start = clock();                                                      \
                                                                               \                                                                                \
         for(i = 0; clock() < start + CLOCKS_PER_SEC / 10; )                   \          for(i = 0; clock() < start + CLOCKS_PER_SEC / 10; i++)                \
           for(j = 0; j < keys_to_test; j++, i++)                              \            for(j = 0; j < keys_to_test; j++)                                   \
             TEST;                                                             \              TEST;                                                             \
                                                                               \                                                                                \
          if ((i < 10) || (keys_to_test * 10 > KEYS_TO_TEST))                  \           if ((i < 10) || (keys_to_test * 10 > max_keys_to_test))              \
            break;                                                             \             break;                                                             \
       }                                                                       \        }                                                                       \
                                                                               \                                                                                \
     start = clock();                                                          \      start = clock();                                                          \
                                                                               \                                                                                \
     for(i = 0; clock() < start + CLOCKS_PER_SEC; )                            \      for(i = 0; clock() < start + CLOCKS_PER_SEC; i += keys_to_test)           \
       for(j = 0; j < keys_to_test; j++, i++)                                  \        for(j = 0; j < keys_to_test; j++)                                       \
         TEST;                                                                 \          TEST;                                                                 \
                                                                               \                                                                                \
     /* Now test for about test_time seconds under keys_to_test keys */        \      /* Now test for about test_time seconds under keys_to_test keys */        \
Line 1146 
Line 1185 
   
 void test_speed(FILE *fd, int keysize, int ivsize, int macsize)  void test_speed(FILE *fd, int keysize, int ivsize, int macsize)
 {  {
   ALIGN(u8, key[KEYS_TO_TEST], MAXKEYSIZEB);    ALIGN(u8, key[MIN_KEYS_TO_TEST], MAXKEYSIZEB);
   ALIGN(u8, iv[KEYS_TO_TEST], MAXIVSIZEB);    ALIGN(u8, iv[MIN_KEYS_TO_TEST], MAXIVSIZEB);
   ALIGN(u8, text[2], TEST_BLOCKS * ECRYPT_BLOCKLENGTH);    ALIGN(u8, *text, MAX(SMALL_BUFFER, FAST_BUFFER) * ECRYPT_BLOCKLENGTH);
 #ifdef ECRYPT_AE  #ifdef ECRYPT_AE
   ALIGN(u8, mac, MAXMACSIZEB);    ALIGN(u8, mac, MAXMACSIZEB);
 #endif  #endif
   
   CTX ctx[KEYS_TO_TEST];    CTX* ctx;
   
   int tests, tests_per_key, keys_to_test;    int tests, tests_per_key, keys_to_test;
   clock_t start, finish;    clock_t start, finish;
Line 1190 
Line 1229 
   
   fprintf(fd, "Size of %s: %d bytes\n\n", QUOTE(CTX), (int)sizeof(CTX));    fprintf(fd, "Size of %s: %d bytes\n\n", QUOTE(CTX), (int)sizeof(CTX));
   
   for(i = 0; i < KEYS_TO_TEST; i++)    text = aligned_malloc(2 * FAST_BUFFER * ECRYPT_BLOCKLENGTH * sizeof(u8));
     ctx = aligned_malloc(MIN_KEYS_TO_TEST * sizeof(CTX));
   
     for(i = 0; i < MIN_KEYS_TO_TEST; i++)
     {      {
       for(j = 0; j < MAXKEYSIZEB; j++)        for(j = 0; j < MAXKEYSIZEB; j++)
         key[i].b[j] = U8V(rand());          key[i].b[j] = U8V(rand());
Line 1202 
Line 1244 
       IVSETUP(&ctx[i], iv[i].b);        IVSETUP(&ctx[i], iv[i].b);
     }      }
   
   for(i = 0; i < TEST_BLOCKS * ECRYPT_BLOCKLENGTH; i++)    for(i = 0; i < FAST_BUFFER * ECRYPT_BLOCKLENGTH; i++)
     text[0].b[i] = U8V(rand());      text[0].b[i] = U8V(rand());
   
   fprintf(fd, "Testing stream encryption speed:\n\n");    fprintf(fd, "Testing stream encryption speed:\n\n");
   fflush(fd);    fflush(fd);
   
   TEST_SPEED(FOR_I_FOR_J, do    TEST_SPEED(MIN_KEYS_TO_TEST, FOR_I_FOR_J, do
     {      {
       ENCRYPT_BLOCKS(&ctx[i % KEYS_TO_TEST],        ENCRYPT_BLOCKS(&ctx[i % MIN_KEYS_TO_TEST],
         text[i % 2].b, text[(i + 1) % 2].b, TEST_BLOCKS);          text[i % 2].b, text[(i + 1) % 2].b, FAST_BUFFER);
   
     } while (0));      } while (0));
   
   fprintf(fd,    fprintf(fd,
     "Encrypted %d blocks of %d bytes (under %d keys, %d blocks/key)\n",      "Encrypted %d blocks of %d bytes (under %d keys, %d blocks/key)\n",
     tests, TEST_BLOCKS * ECRYPT_BLOCKLENGTH, keys_to_test, tests_per_key);      tests, FAST_BUFFER * ECRYPT_BLOCKLENGTH, keys_to_test, tests_per_key);
   
   fprintf(fd, "Total time: %d clock ticks (%.2f seconds)\n",    fprintf(fd, "Total time: %d clock ticks (%.2f seconds)\n",
     clocks, (double)clocks / (double)CLOCKS_PER_SEC);      clocks, (double)clocks / (double)CLOCKS_PER_SEC);
   
   usec /= (double)(TEST_BLOCKS * ECRYPT_BLOCKLENGTH);    usec /= (double)(FAST_BUFFER * ECRYPT_BLOCKLENGTH);
   usec_enc = usec;    usec_enc = usec;
   
   fprintf(fd, "Encryption speed (cycles/byte): %.2f\n", usec * cpu_speed);    fprintf(fd, "Encryption speed (cycles/byte): %.2f\n", usec * cpu_speed);
Line 1230 
Line 1272 
   
   fprintf(fd, "\n");    fprintf(fd, "\n");
   
   for(i = 0; i < KEYS_TO_TEST; i++)    for(i = 0; i < MIN_KEYS_TO_TEST; i++)
     FINALIZE(&ctx[i], mac.b);      FINALIZE(&ctx[i], mac.b);
   
   if (test_packet)    if (test_packet)
Line 1240 
Line 1282 
   
       for (k = 0; k < 3; k++)        for (k = 0; k < 3; k++)
         {          {
           TEST_SPEED(FOR_I_FOR_J, do            TEST_SPEED(MIN_KEYS_TO_TEST, FOR_I_FOR_J, do
           {            {
             ENCRYPT_PACKET(&ctx[i % KEYS_TO_TEST], iv[j % KEYS_TO_TEST].b,              ENCRYPT_PACKET(&ctx[i % MIN_KEYS_TO_TEST],
               NULL, 0, text[i % 2].b, text[(i + 1) % 2].b, sizes[k], mac.b);                iv[j % MIN_KEYS_TO_TEST].b, NULL, 0,
                 text[i % 2].b, text[(i + 1) % 2].b, sizes[k], mac.b);
   
           } while (0));            } while (0));
   
Line 1294 
Line 1337 
       fprintf(fd, "Testing key setup speed:\n\n");        fprintf(fd, "Testing key setup speed:\n\n");
       fflush(fd);        fflush(fd);
   
       TEST_SPEED(FOR_J_FOR_I, do        TEST_SPEED(MIN_KEYS_TO_TEST, FOR_J_FOR_I, do
       {        {
         KEYSETUP(&ctx[0], key[i % KEYS_TO_TEST].b, keysize, ivsize, macsize);          KEYSETUP(&ctx[0], key[i % MIN_KEYS_TO_TEST].b,
             keysize, ivsize, macsize);
   
       } while (0));        } while (0));
   
Line 1319 
Line 1363 
 #endif  #endif
       fflush(fd);        fflush(fd);
   
       TEST_SPEED(FOR_I_FOR_J, do        TEST_SPEED(MIN_KEYS_TO_TEST, FOR_I_FOR_J, do
       {        {
         IVSETUP(&ctx[i % KEYS_TO_TEST], iv[j % KEYS_TO_TEST].b);          IVSETUP(&ctx[i % MIN_KEYS_TO_TEST], iv[j % MIN_KEYS_TO_TEST].b);
         FINALIZE(&ctx[i % KEYS_TO_TEST], mac.b);          FINALIZE(&ctx[i % MIN_KEYS_TO_TEST], mac.b);
   
       } while (0));        } while (0));
   
Line 1340 
Line 1384 
       fflush(fd);        fflush(fd);
     }      }
   
     if (test_agility)
       {
         int* order;
         int current = 0;
   
         aligned_free(ctx);
         ctx = aligned_malloc(MAX_KEYS_TO_TEST * sizeof(CTX));
         order = malloc(MAX_KEYS_TO_TEST * sizeof(int));
   
         for(i = 0; i < MAX_KEYS_TO_TEST; i++)
           {
             for(j = 0; j < MAXKEYSIZEB; j++)
               key[0].b[j] = U8V(rand());
   
             for(j = 0; j < MAXIVSIZEB; j++)
               iv[0].b[j] = U8V(rand());
   
             KEYSETUP(&ctx[i], key[0].b, keysize, ivsize, macsize);
             IVSETUP(&ctx[i], iv[0].b);
           }
   
         for(i = 0; i < MAX_KEYS_TO_TEST; i++)
           order[i] = i;
   
         for(i = 0; i < MAX_KEYS_TO_TEST; i++)
           {
             const int j = i + (rand() % (MAX_KEYS_TO_TEST - i));
             const int tmp = order[i];
   
             order[i] = order[j];
             order[j] = tmp;
           }
   
         fprintf(fd, "Testing key agility:\n\n");
         fflush(fd);
   
         TEST_SPEED(MAX_KEYS_TO_TEST, FOR_J_FOR_I, do
         {
           ENCRYPT_BLOCKS(&ctx[order[(++current) % MAX_KEYS_TO_TEST]],
             text[i % 2].b, text[(i + 1) % 2].b, SMALL_BUFFER);
   
         } while (0));
   
         fprintf(fd,
           "Encrypted %d blocks of %d bytes (each time switching contexts)\n",
           tests, SMALL_BUFFER * ECRYPT_BLOCKLENGTH);
   
         fprintf(fd, "Total time: %d clock ticks (%.2f seconds)\n",
           clocks, (double)clocks / (double)CLOCKS_PER_SEC);
   
         usec /= (double)(SMALL_BUFFER * ECRYPT_BLOCKLENGTH);
   
         fprintf(fd, "Encryption speed (cycles/byte): %.2f\n", usec * cpu_speed);
         fprintf(fd, "Encryption speed (Mbps): %.2f\n", 8.0 / usec);
         fprintf(fd, "Overhead: %.1f%%\n", 100.0 * (usec / usec_enc - 1.0));
   
         fprintf(fd, "\n");
   
         for(i = 0; i < MAX_KEYS_TO_TEST; i++)
           FINALIZE(&ctx[i], mac.b);
   
         free(order);
       }
   
   fprintf(fd, "\nEnd of performance measurements\n");    fprintf(fd, "\nEnd of performance measurements\n");
   fflush(fd);    fflush(fd);
   
     aligned_free(text);
     aligned_free(ctx);
 }  }
   
 /* ------------------------------------------------------------------------- */  /* ------------------------------------------------------------------------- */
Line 1364 
Line 1475 
   
 int main(int argc, char *argv[])  int main(int argc, char *argv[])
 {  {
   int keysize = ECRYPT_KEYSIZE(0);    int numtests = 0;
   int ivsize = ECRYPT_IVSIZE(0);  
   int macsize = ECRYPT_MACSIZE(0);    int keytarget[8];
     int ivtarget[8];
     int mactarget[8];
   
   int k, i, m;    int keysize[8];
     int ivsize[8];
     int macsize[8];
   
     int k, i, m, j;
     int s;
   
     while(argc > 1)
       {
         char* p = *(++argv);
         argc--;
   
   while((argc > 1) && (argv[1][0] == '-'))        switch (*(p++))
     {      {
       switch (argv[1][1])          case '-':
             while (*p)
               switch (*(p++))
         {          {
         case 'v':          case 'v':
           output_vectors = 1;            output_vectors = 1;
           break;            break;
         case 'c':          case 'c':
                   if (!(*p) && (argc > 1))
                     {
                       p = *(++argv);
           argc--;            argc--;
           argv++;                    }
   
           if (argc > 1)  
             cpu_speed = atof(argv[1]);  
   
                   cpu_speed = strtod(p, &p);
           break;            break;
         case 't':          case 't':
                   if (!(*p) && (argc > 1))
                     {
                       p = *(++argv);
           argc--;            argc--;
           argv++;                    }
   
           if (argc > 1)  
             test_time = atof(argv[1]);  
   
                   test_time = strtod(p, &p);
           break;            break;
         case 'p':          case 'p':
           test_packet = 0;            test_packet = 0;
Line 1399 
Line 1526 
         case 'k':          case 'k':
           test_setup = 0;            test_setup = 0;
           break;            break;
                 case 'a':
                   test_agility = 0;
                   break;
         case 's':          case 's':
           single_key = 1;                  if (!(*p) && (argc > 1))
                     {
                       p = *(++argv);
                       argc--;
                     }
   
                   keytarget[numtests] = strtol(p, &p, 0);
   
                   if (!(*p) && (argc > 1))
                     {
                       p = *(++argv);
                       argc--;
                     }
   
                   ivtarget[numtests] = strtol(p, &p, 0);
   
                   if (!(*p) && (argc > 1))
                     {
                       p = *(++argv);
                       argc--;
                     }
   
                   mactarget[numtests] = strtol(p, &p, 0);
   
                   if (numtests + 1 < 8)
                     numtests++;
   
           break;            break;
         case 'q':          case 'q':
           quiet = 1;            quiet = 1;
           break;            break;
                 default:
                   fprintf(stderr, "warning: invalid option '%c'\n", p[-1]);
                 }
             break;
           default:
             fprintf(stderr, "warning: invalid argument '%s'\n", argv[0]);
         }          }
   
       argc--;  
       argv++;  
     }      }
   
   if (!output_vectors && (cpu_speed <= 0))    if (!output_vectors && (cpu_speed <= 0))
     {      {
       printf("Usage: ecrypt-test [OPTIONS]\n"        fprintf(stderr,
           "Usage: ecrypt-test [OPTIONS]\n"
              "\n"               "\n"
              "  -v      generate test vectors\n"               "  -v      generate test vectors\n"
              "  -c MHZ  perform speed measurements assuming the given "               "  -c MHZ  perform speed measurements assuming the given "
Line 1421 
Line 1581 
              "  -t SEC  limit the duration of the tests (default: 3 seconds)\n"               "  -t SEC  limit the duration of the tests (default: 3 seconds)\n"
              "  -p      do not test packet encryption speed\n"               "  -p      do not test packet encryption speed\n"
              "  -k      do not test key and IV setup speed\n"               "  -k      do not test key and IV setup speed\n"
              "  -s      perform tests for a single key and IV length\n"          "  -a      do not test key agility\n"
           "  -s KEY IV MAC\n"
           "          only perform tests for specified key/IV/MAC length\n"
           "          (this option can be specified more than once)\n"
              "  -q      be quiet\n");               "  -q      be quiet\n");
   
       exit(2);        exit(2);
Line 1431 
Line 1594 
   
   ECRYPT_init();    ECRYPT_init();
   
   for (k = 0; ECRYPT_KEYSIZE(k) <= ECRYPT_MAXKEYSIZE; k++)    if (numtests > 0)
       for (j = 0; j < numtests; ++j)
         {
           keysize[j] = ECRYPT_KEYSIZE(0);
           ivsize[j] = ECRYPT_IVSIZE(0);
           macsize[j] = ECRYPT_MACSIZE(0);
         }
     else
       keysize[0] = ivsize[0] = macsize[0] = -1;
   
     for (k = 0, j = 0; (s = ECRYPT_KEYSIZE(k)) <= ECRYPT_MAXKEYSIZE; k++)
     {      {
       if ((k > 0) && (ECRYPT_KEYSIZE(k) <= ECRYPT_KEYSIZE(k - 1)))        if ((k > 0) && (s <= ECRYPT_KEYSIZE(k - 1)))
         {          {
           ++errors;            ++errors;
           fprintf(stdout,            fprintf(stdout,
Line 1441 
Line 1614 
           break;            break;
         }          }
   
       if (abs(ECRYPT_KEYSIZE(k) - 128) < abs(keysize - 128))        if (numtests > 0)
         keysize = ECRYPT_KEYSIZE(k);          {
             for (j = 0; j < numtests; ++j)
               if (abs(s - keytarget[j]) < abs(keysize[j] - keytarget[j]))
                 keysize[j] = s;
           }
         else
           /* Only powers of 2 or multiples of 80 between 64 and 256 */
           if ((s >= 64) && (s <= 256) && (!(s & (s - 1)) || !(s % 80)))
               {
                 keysize[j] = s;
                 keysize[++j] = -1;
               }
     }      }
   
   for (i = 0; ECRYPT_IVSIZE(i) <= ECRYPT_MAXIVSIZE; i++)    for (i = 0, j = 0; (s = ECRYPT_IVSIZE(i)) <= ECRYPT_MAXIVSIZE; i++)
     {      {
       if ((i > 0) && (ECRYPT_IVSIZE(i) <= ECRYPT_IVSIZE(i - 1)))        if ((i > 0) && (s <= ECRYPT_IVSIZE(i - 1)))
         {          {
           ++errors;            ++errors;
           fprintf(stdout,            fprintf(stdout,
Line 1455 
Line 1639 
           break;            break;
         }          }
   
       if (abs(ECRYPT_IVSIZE(i) - 64) < abs(ivsize - 64))        if (numtests > 0)
         ivsize = ECRYPT_IVSIZE(i);          {
             for (j = 0; j < numtests; ++j)
               if (abs(s - ivtarget[j]) < abs(ivsize[j] - ivtarget[j]))
                 ivsize[j] = s;
           }
         else
           /* Only powers of 2 larger than 32 or multiples of 80 */
           if ((s <= 256) && (((s >= 32) && !(s & (s - 1))) || !(s % 80)))
               {
                 ivsize[j] = s;
                 ivsize[++j] = -1;
               }
     }      }
   
   for (m = 0; ECRYPT_MACSIZE(m) <= ECRYPT_MAXMACSIZE; m++)    for (m = 0, j = 0; (s = ECRYPT_MACSIZE(m)) <= ECRYPT_MAXMACSIZE; m++)
     {      {
       if ((m > 0) && (ECRYPT_MACSIZE(m) <= ECRYPT_MACSIZE(m - 1)))        if ((m > 0) && (s <= ECRYPT_MACSIZE(m - 1)))
         {          {
           ++errors;            ++errors;
           fprintf(stdout,            fprintf(stdout,
Line 1469 
Line 1664 
           break;            break;
         }          }
   
       if (abs(ECRYPT_MACSIZE(m) - 64) < abs(macsize - 64))        if (numtests > 0)
         macsize = ECRYPT_MACSIZE(m);          {
             for (j = 0; j < numtests; ++j)
               if (abs(s - mactarget[j]) < abs(macsize[j] - mactarget[j]))
                 macsize[j] = s;
     }      }
   
   check_status();  
   
   if (single_key)  
     run_tests(stdout, keysize, ivsize, macsize);  
   else    else
     for (k = 0; (keysize=ECRYPT_KEYSIZE(k)) <= ECRYPT_MAXKEYSIZE; k++)          /* Only multiples of 32 smaller than 128 */
           if (!(s % 32) && (s <= 128))
       {        {
         if ((k > 0) && (keysize <= ECRYPT_KEYSIZE(k - 1)))                macsize[j] = s;
           break;                macsize[++j] = -1;
               }
         /* Only powers of 2 or multiples of 80 larger than 64 */      }
         if (((keysize & (keysize - 1)) && (keysize % 80)) || (keysize < 64))  
           continue;  
   
         /* Not interested in key sizes exceeding 256 bits */    check_status();
         if (keysize > 256)  
           break;  
   
         for (i = 0; (ivsize=ECRYPT_IVSIZE(i)) <= ECRYPT_MAXIVSIZE; i++)    if (numtests > 0)
       for (j = 0; j < numtests; j++)
           {            {
             if ((i > 0) && (ivsize <= ECRYPT_IVSIZE(i - 1)))          int duplicate = 0;
               break;  
   
             /* Only powers of 2 larger than 32 or multiples of 80 */  
             if (((ivsize & (ivsize - 1)) || (ivsize < 32)) && (ivsize % 80))  
               continue;  
   
             /* Not interested in IV sizes exceeding 256 bits */  
             if (ivsize > 256)  
               break;  
   
             for (m = 0; (macsize=ECRYPT_MACSIZE(m)) <= ECRYPT_MAXMACSIZE; m++)          for (i = 0; i < j; i++)
             if ((keysize[i] == keysize[j]) &&
                 (ivsize[i] == ivsize[j]) &&
                 (macsize[i] == macsize[j]))
               {                {
                 if ((m > 0) && (macsize <= ECRYPT_MACSIZE(m - 1)))                duplicate = 1;
                   break;  
   
                 /* Only multiples of 32 */  
                 if (macsize % 32)  
                   continue;  
   
                 /* Not interested in MAC sizes exceeding 256 bits */  
                 if (macsize > 256)  
                   break;                    break;
   
                 run_tests(stdout, keysize, ivsize, macsize);  
               }  
           }            }
   
           if (!duplicate)
             run_tests(stdout, keysize[j], ivsize[j], macsize[j]);
       }        }
     else
       for (k = 0; keysize[k] >= 0; k++)
         for (i = 0; ivsize[i] >= 0; i++)
           for (m = 0; macsize[m] >= 0; m++)
             run_tests(stdout, keysize[k], ivsize[i], macsize[m]);
   
   if (!quiet)    if (!quiet)
     {      {

Generate output suitable for use with a patch program
Legend:
Removed from v.78  
changed lines
  Added in v.107
eSTREAM Project

Powered by ViewCVS 1.0-dev 		(Powered by Apache)

ViewCVS and CVS Help