Changeset a7282fb for tools/traceanon/rijndael.c

Timestamp:

11/14/06 13:56:01 (14 years ago)

Author:

Perry Lorier <perry@…>

Branches:

4.0.1-hotfixes, cachetimestamps, develop, dpdk-ndag, etsilive, getfragoff, help, libtrace4, master, ndag_format, pfring, rc-4.0.1, rc-4.0.2, rc-4.0.3, rc-4.0.4, ringdecrementfix, ringperformance, ringtimestampfixes

Children:

2595c4d

Parents:

35e0869

Message:

Fix lots of little warnings

File:

• tools/traceanon/rijndael.c (modified) (14 diffs)

tools/traceanon/rijndael.c

@@ -1 @@
-// $Id$
-
-//
+/* $Id$ */
+
+/*
 // File : rijndael.cpp
 // Creation date : Sun Nov 5 2000 03:22:10 CEST
@@ -10 +10 @@
 // This code is public domain.
 // Based on the Vincent Rijmen and K.U.Leuven implementation 2.4.
-//
-
-//
+*/
+
+/*
 // Original Copyright notice:
 //
@@ -28 +28 @@
 //
 //    This code is placed in the public domain.
-//
-
-//
+*/
+
+/*
 // This implementation works on 128 , 192 , 256 bit keys
 // and on 128 bit blocks
-//
+*/
 
 #define _RIJNDAEL_CPP_
@@ -971 +971 @@
 
 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/*////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // API
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////// */
 
 int rijndael_init(Mode mode,Direction dir,const UINT8 * key,KeyLength keyLen,UINT8 * initVector)
@@ -982 +982 @@
         UINT32 j; 
 
-        // Not initialized yet
+        /* Not initialized yet */
         m_state = Invalid;
 
-        // Check the mode
+        /* Check the mode */
         if((mode != CBC) && (mode != ECB) && (mode != CFB1))return RIJNDAEL_UNSUPPORTED_MODE;
         m_mode = mode;
 
-        // And the direction
+        /* And the direction */
         if((dir != Encrypt) && (dir != Decrypt))return RIJNDAEL_UNSUPPORTED_DIRECTION;
         m_direction = dir;
 
-        // Allow to set an init vector
+        /* Allow to set an init vector */
         if(initVector)
         {
-                // specified init vector
+                /* specified init vector */
                 for(i = 0;i < MAX_IV_SIZE;i++)
                 {
@@ -1002 +1002 @@
                 }
         } else {
-                // zero init vector
+                /* zero init vector */
                 for(i = 0;i < MAX_IV_SIZE;i++)
                 {
@@ -1010 +1010 @@
 
 
-        // And check the key length
+        /* And check the key length */
         switch(keyLen)
         {
@@ -1029 +1029 @@
                         break;
         }
-        // The number of rounds is calculated as
+        /* The number of rounds is calculated as
         // m_uRounds = (m_uKeyLenInBits / 32) + 6;
+        */
 
         if(!key)return RIJNDAEL_BAD_KEY;
@@ -1154 +1155 @@
                         }
                         padLen = 16 - (inputOctets - 16*numBlocks);
-                        //                      assert(padLen > 0 && padLen <= 16);
                         memcpy(block, input, 16 - padLen);
                         memset(block + 16 - padLen, padLen, padLen);
@@ -1173 +1173 @@
                         }
                         padLen = 16 - (inputOctets - 16*numBlocks);
-                        //                      assert(padLen > 0 && padLen <= 16); // DO SOMETHING HERE ?
                         for (i = 0; i < 16 - padLen; i++) {
                                 block[i] = input[i] ^ iv[i];
@@ -1358 +1357 @@
 }
 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/*////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // ALGORITHM
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////// */
 
 
@@ -1369 +1368 @@
         int t = 0;
 
-        // Calculate the necessary round keys
-        // The number of calculations depends on keyBits and blockBits
+        /* Calculate the necessary round keys */
+        /* The number of calculations depends on keyBits and blockBits */
         int uKeyColumns = m_uRounds - 6;
 
         UINT8 tempKey[_MAX_KEY_COLUMNS][4];
 
-        // Copy the input key to the temporary key matrix
+        /* Copy the input key to the temporary key matrix */
 
         for(j = 0;j < uKeyColumns;j++)
@@ -1383 +1382 @@
 
 
-        // copy values into round key array
+        /* copy values into round key array */
         for(j = 0;(j < uKeyColumns) && (r <= m_uRounds); )
         {
@@ -1540 +1539 @@
         UINT8 temp[4][4];
 
-        *((UINT32*)temp[0]) = *((UINT32*)(a   )) ^ *((UINT32*)m_expandedKey[m_uRounds][0]);
-        *((UINT32*)temp[1]) = *((UINT32*)(a+ 4)) ^ *((UINT32*)m_expandedKey[m_uRounds][1]);
-        *((UINT32*)temp[2]) = *((UINT32*)(a+ 8)) ^ *((UINT32*)m_expandedKey[m_uRounds][2]);
-        *((UINT32*)temp[3]) = *((UINT32*)(a+12)) ^ *((UINT32*)m_expandedKey[m_uRounds][3]);
-
-        *((UINT32*)(b   )) = *((UINT32*)T5[temp[0][0]])
-                ^ *((UINT32*)T6[temp[3][1]])
-                ^ *((UINT32*)T7[temp[2][2]]) 
-                ^ *((UINT32*)T8[temp[1][3]]);
-        *((UINT32*)(b+ 4)) = *((UINT32*)T5[temp[1][0]])
-                ^ *((UINT32*)T6[temp[0][1]])
-                ^ *((UINT32*)T7[temp[3][2]]) 
-                ^ *((UINT32*)T8[temp[2][3]]);
+        *((UINT32*)temp[0]) = *((const UINT32*)(a   )) ^ *((const UINT32*)m_expandedKey[m_uRounds][0]);
+        *((UINT32*)temp[1]) = *((const UINT32*)(a+ 4)) ^ *((const UINT32*)m_expandedKey[m_uRounds][1]);
+        *((UINT32*)temp[2]) = *((const UINT32*)(a+ 8)) ^ *((const UINT32*)m_expandedKey[m_uRounds][2]);
+        *((UINT32*)temp[3]) = *((const UINT32*)(a+12)) ^ *((const UINT32*)m_expandedKey[m_uRounds][3]);
+
+        *((UINT32*)(b   )) = *((const UINT32*)T5[temp[0][0]])
+                ^ *((const UINT32*)T6[temp[3][1]])
+                ^ *((const UINT32*)T7[temp[2][2]]) 
+                ^ *((const UINT32*)T8[temp[1][3]]);
+        *((UINT32*)(b+ 4)) = *((const UINT32*)T5[temp[1][0]])
+                ^ *((const UINT32*)T6[temp[0][1]])
+                ^ *((const UINT32*)T7[temp[3][2]]) 
+                ^ *((const UINT32*)T8[temp[2][3]]);
         *((UINT32*)(b+ 8)) = *((UINT32*)T5[temp[2][0]])
-                ^ *((UINT32*)T6[temp[1][1]])
-                ^ *((UINT32*)T7[temp[0][2]]) 
-                ^ *((UINT32*)T8[temp[3][3]]);
+                ^ *((const UINT32*)T6[temp[1][1]])
+                ^ *((const UINT32*)T7[temp[0][2]]) 
+                ^ *((const UINT32*)T8[temp[3][3]]);
         *((UINT32*)(b+12)) = *((UINT32*)T5[temp[3][0]])
-                ^ *((UINT32*)T6[temp[2][1]])
-                ^ *((UINT32*)T7[temp[1][2]]) 
-                ^ *((UINT32*)T8[temp[0][3]]);
+                ^ *((const UINT32*)T6[temp[2][1]])
+                ^ *((const UINT32*)T7[temp[1][2]]) 
+                ^ *((const UINT32*)T8[temp[0][3]]);
         for(r = m_uRounds-1; r > 1; r--)
         {