Made keyread (key scanning) a key specific attribute.

This avoids using fulltext keys for table scanning.
This also reverts Sinisa's original fix for this problem.


Docs/manual.texi:
  Update of SQL_JOIN_MAX_SIZE information3602
client/mysqldump.c:
  comment cleanup
include/my_aes.h:
  General cleanup for new file
include/rijndael.h:
  General cleanup for new file
include/sha1.h:
  General cleanup for new file
mysys/my_aes.c:
  General cleanup for new file
mysys/rijndael.c:
  General cleanup for new file
mysys/sha1.c:
  General cleanup for new file
sql/ha_berkeley.h:
  Made keyread (key scanning) a key specific attribute.
sql/ha_innodb.cc:
  Merge with 3.23.x
sql/ha_innodb.h:
  Made keyread (key scanning) a key specific attribute.
sql/ha_isam.cc:
  Moved things to table_flags()
sql/ha_isam.h:
  Made keyread (key scanning) a key specific attribute.
sql/ha_myisam.cc:
  Made keyread (key scanning) a key specific attribute.
sql/ha_myisam.h:
  Made keyread (key scanning) a key specific attribute.
sql/ha_myisammrg.h:
  Made keyread (key scanning) a key specific attribute.
sql/handler.h:
  Made keyread (key scanning) a key specific attribute.
sql/item_strfunc.cc:
  Cleanup of AES_xxx code
sql/opt_range.cc:
  Made keyread (key scanning) a key specific attribute.
sql/sql_base.cc:
  Made keyread (key scanning) a key specific attribute.
sql/sql_cache.cc:
  Removed compiler warning
sql/sql_select.cc:
  Removed wrong patch to fulltext problem
sql/table.cc:
  Made keyread (key scanning) a key specific attribute.
sql/table.h:
  Made keyread (key scanning) a key specific attribute.

1 files changed, 169 insertions, 225 deletions

diff --git a/mysys/sha1.c b/mysys/sha1.c
index 82ccab2c6ce..3b4bac84d08 100644
--- a/mysys/sha1.c
+++ b/mysys/sha1.c
@@ -4,54 +4,49 @@
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.
- 
+
  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
- 
+
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
- 
+
 /*
- sha1.c
- Original Source from: http://www.faqs.org/rfcs/rfc3174.html
- 
- Description:
-       This file implements the Secure Hashing Algorithm 1 as
-       defined in FIPS PUB 180-1 published April 17, 1995.
- 
-       The SHA-1, produces a 160-bit message digest for a given
-       data stream.  It should take about 2**n steps to find a
-       message with the same digest as a given message and
-       2**(n/2) to find any two messages with the same digest,
-       when n is the digest size in bits.  Therefore, this
-       algorithm can serve as a means of providing a
-       "fingerprint" for a message.
- 
-   Portability Issues:
-       SHA-1 is defined in terms of 32-bit "words".  This code
-       uses <stdint.h> (included via "sha1.h" to define 32 and 8
-       bit unsigned integer types.  If your C compiler does not
-       support 32 bit unsigned integers, this code is not
-       appropriate.
- 
-   Caveats:
-       SHA-1 is designed to work with messages less than 2^64 bits
-       long.  Although SHA-1 allows a message digest to be generated
-       for messages of any number of bits less than 2^64, this
-       implementation only works with messages with a length that is
-       a multiple of the size of an 8-bit character.
- 
-*/
- 
-/* 
-  Modified 2002 by Peter Zaitsev to 
-  - fit to new prototypes according to MySQL standard
-  - Some optimizations 
-  - All checking is now done in debug only mode
-  - More comments 
+  Original Source from: http://www.faqs.org/rfcs/rfc3174.html
+
+ DESCRIPTION
+   This file implements the Secure Hashing Algorithm 1 as
+   defined in FIPS PUB 180-1 published April 17, 1995.
+
+   The SHA-1, produces a 160-bit message digest for a given data
+   stream.  It should take about 2**n steps to find a message with the
+   same digest as a given message and 2**(n/2) to find any two
+   messages with the same digest, when n is the digest size in bits.
+   Therefore, this algorithm can serve as a means of providing a
+   "fingerprint" for a message.
+
+ PORTABILITY ISSUES
+   SHA-1 is defined in terms of 32-bit "words".  This code uses
+   <stdint.h> (included via "sha1.h" to define 32 and 8 bit unsigned
+   integer types.  If your C compiler does not support 32 bit unsigned
+   integers, this code is not appropriate.
+
+ CAVEATS
+   SHA-1 is designed to work with messages less than 2^64 bits long.
+   Although SHA-1 allows a message digest to be generated for messages
+   of any number of bits less than 2^64, this implementation only
+   works with messages with a length that is a multiple of the size of
+   an 8-bit character.
+
+  CHANGES
+    2002 by Peter Zaitsev to
+     - fit to new prototypes according to MySQL standard
+     - Some optimizations
+     - All checking is now done in debug only mode
+     - More comments
 */
 
 #include "my_global.h"
@@ -59,32 +54,33 @@
 #include "sha1.h"
 
 /*
- Define the SHA1 circular left shift macro
+  Define the SHA1 circular left shift macro
 */
- 
+
 #define SHA1CircularShift(bits,word) \
-                (((word) << (bits)) | ((word) >> (32-(bits))))
+		(((word) << (bits)) | ((word) >> (32-(bits))))
 
 /* Local Function Prototyptes */
-void SHA1PadMessage(SHA1_CONTEXT*);
-void SHA1ProcessMessageBlock(SHA1_CONTEXT*);
+static void SHA1PadMessage(SHA1_CONTEXT*);
+static void SHA1ProcessMessageBlock(SHA1_CONTEXT*);
+
 
 /*
- sha1_reset
- 
- Description:
-       This function will initialize the SHA1Context in preparation
-       for computing a new SHA1 message digest.
- 
- Parameters:
-       context: [in/out]
-           The context to reset.
- 
- Returns:
-       sha Error Code.
- 
+  Initialize SHA1Context
+
+  SYNOPSIS
+    sha1_reset()
+    context [in/out]		The context to reset.
+
+ DESCRIPTION
+   This function will initialize the SHA1Context in preparation
+   for computing a new SHA1 message digest.
+
+ RETURN
+   SHA_SUCCESS		ok
+   != SHA_SUCCESS	sha Error Code.
 */
- 
+
 
 const uint32 sha_const_key[5]=
 {
@@ -98,17 +94,14 @@ const uint32 sha_const_key[5]=
 
 int sha1_reset(SHA1_CONTEXT *context)
 {
-
-#ifndef DBUG_OFF 
+#ifndef DBUG_OFF
   if (!context)
-  {
     return SHA_NULL;
-  }
-#endif    
+#endif
+
+  context->Length		  = 0;
+  context->Message_Block_Index	  = 0;
 
-  context->Length                 = 0;
-  context->Message_Block_Index    = 0;
-  
   context->Intermediate_Hash[0]   = sha_const_key[0];
   context->Intermediate_Hash[1]   = sha_const_key[1];
   context->Intermediate_Hash[2]   = sha_const_key[2];
@@ -121,165 +114,124 @@ int sha1_reset(SHA1_CONTEXT *context)
   return SHA_SUCCESS;
 }
 
+
 /*
- sha1_result
- 
- Description:
-       This function will return the 160-bit message digest into the
-       Message_Digest array  provided by the caller.
-       NOTE: The first octet of hash is stored in the 0th element,
-             the last octet of hash in the 19th element.
- 
- Parameters:
-       context: [in/out]
-           The context to use to calculate the SHA-1 hash.
-       Message_Digest: [out]
-           Where the digest is returned.
- 
- Returns:
-       sha Error Code.
- 
+   Return the 160-bit message digest into the array provided by the caller
+
+  SYNOPSIS
+    sha1_result()
+    context [in/out]		The context to use to calculate the SHA-1 hash.
+    Message_Digest: [out]	Where the digest is returned.
+
+  DESCRIPTION
+    NOTE: The first octet of hash is stored in the 0th element,
+	  the last octet of hash in the 19th element.
+
+ RETURN
+   SHA_SUCCESS		ok
+   != SHA_SUCCESS	sha Error Code.
 */
 
-int sha1_result( SHA1_CONTEXT *context,
-                uint8 Message_Digest[SHA1_HASH_SIZE])
+int sha1_result(SHA1_CONTEXT *context,
+		uint8 Message_Digest[SHA1_HASH_SIZE])
 {
   int i;
-    
-#ifndef DBUG_OFF 
+
+#ifndef DBUG_OFF
   if (!context || !Message_Digest)
-  {
     return SHA_NULL;
-  }
 
   if (context->Corrupted)
-  {
     return context->Corrupted;
-  }
+#endif
 
   if (!context->Computed)
   {
-
-#endif     
     SHA1PadMessage(context);
      /* message may be sensitive, clear it out */
     bzero((char*) context->Message_Block,64);
     context->Length   = 0;    /* and clear length  */
     context->Computed = 1;
-
-#ifndef DBUG_OFF
   }
-#endif
 
   for (i = 0; i < SHA1_HASH_SIZE; i++)
-  {
-    Message_Digest[i] = (context->Intermediate_Hash[i>>2] >> 8 
-                         * ( 3 - ( i & 0x03 ) ));
-  }
-  
+    Message_Digest[i] = (context->Intermediate_Hash[i>>2] >> 8
+			 * ( 3 - ( i & 0x03 ) ));
   return SHA_SUCCESS;
 }
 
+
 /*
- sha1_input
- 
- Description:
-       This function accepts an array of octets as the next portion
-       of the message.
- 
-   Parameters:
-       context: [in/out]
-           The SHA context to update
-       message_array: [in]
-           An array of characters representing the next portion of
-           the message.
-       length: [in]
-           The length of the message in message_array
- 
-   Returns:
-       sha Error Code.
- 
+  Accepts an array of octets as the next portion of the message.
+
+  SYNOPSIS
+   sha1_input()
+   context [in/out]	The SHA context to update
+   message_array	An array of characters representing the next portion
+			of the message.
+  length		The length of the message in message_array
+
+ RETURN
+   SHA_SUCCESS		ok
+   != SHA_SUCCESS	sha Error Code.
 */
 
 int sha1_input(SHA1_CONTEXT *context, const uint8 *message_array,
-               unsigned length)
+	       unsigned length)
 {
   if (!length)
-  {
     return SHA_SUCCESS;
-  }
-#ifndef DBUG_OFF 
+
+#ifndef DBUG_OFF
   /* We assume client konows what it is doing in non-debug mode */
   if (!context || !message_array)
-  {
     return SHA_NULL;
-  }
   if (context->Computed)
-  {
-    context->Corrupted = SHA_STATE_ERROR;
-    return SHA_STATE_ERROR;
-  }
-
+    return (context->Corrupted= SHA_STATE_ERROR);
   if (context->Corrupted)
-  {
     return context->Corrupted;
-  }    
-#endif     
+#endif
 
   while (length--)
   {
-    context->Message_Block[context->Message_Block_Index++] =
-                    (*message_array & 0xFF);
-    context->Length  += 8;  /* Length is in bits */ 
-
-#ifndef DBUG_OFF    
-    /* 
-     Then we're not debugging we assume we never will get message longer
-     2^64 bits.
+    context->Message_Block[context->Message_Block_Index++]=
+      (*message_array & 0xFF);
+    context->Length  += 8;  /* Length is in bits */
+
+#ifndef DBUG_OFF
+    /*
+      Then we're not debugging we assume we never will get message longer
+      2^64 bits.
     */
     if (context->Length == 0)
-    {
-      /* Message is too long */
-      context->Corrupted = 1;
-      return 1;
-    }
-#endif 
-	
+      return (context->Corrupted= 1);	   /* Message is too long */
+#endif
+
     if (context->Message_Block_Index == 64)
     {
       SHA1ProcessMessageBlock(context);
     }
-    message_array++;  
+    message_array++;
   }
-  
   return SHA_SUCCESS;
 }
 
+
 /*
-   SHA1ProcessMessageBlock
- 
-   Description:
-       This function will process the next 512 bits of the message
-       stored in the Message_Block array.
- 
-   Parameters:
-       None.
- 
-   Returns:
-       Nothing.
- 
-   Comments:
-
-       Many of the variable names in this code, especially the
-       single character names, were used because those were the
-       names used in the publication.
- 
- 
+  Process the next 512 bits of the message stored in the Message_Block array.
+
+  SYNOPSIS
+    SHA1ProcessMessageBlock()
+
+   DESCRIPTION
+     Many of the variable names in this code, especially the single
+     character names, were used because those were the names used in
+     the publication.
 */
 
-/* Constants defined in SHA-1   */
-static const uint32  K[]=   
-{ 
+/* Constants defined in SHA-1	*/
+static const uint32  K[]=
+{
   0x5A827999,
   0x6ED9EBA1,
   0x8F1BBCDC,
@@ -287,17 +239,17 @@ static const uint32  K[]=
 };
 
 
-void SHA1ProcessMessageBlock(SHA1_CONTEXT *context)
+static void SHA1ProcessMessageBlock(SHA1_CONTEXT *context)
 {
-  int           t;                 /* Loop counter                */
-  uint32        temp;              /* Temporary word value        */
-  uint32        W[80];             /* Word sequence               */
-  uint32        A, B, C, D, E;     /* Word buffers                */
+  int		t;		   /* Loop counter		  */
+  uint32	temp;		   /* Temporary word value	  */
+  uint32	W[80];		   /* Word sequence		  */
+  uint32	A, B, C, D, E;	   /* Word buffers		  */
   int index;
-    
+
   /*
-   Initialize the first 16 words in the array W
-   */
+    Initialize the first 16 words in the array W
+  */
 
   for (t = 0; t < 16; t++)
   {
@@ -322,15 +274,14 @@ void SHA1ProcessMessageBlock(SHA1_CONTEXT *context)
 
   for (t = 0; t < 20; t++)
   {
-    temp =  SHA1CircularShift(5,A) +
-            ((B & C) | ((~B) & D)) + E + W[t] + K[0];
+    temp= SHA1CircularShift(5,A) + ((B & C) | ((~B) & D)) + E + W[t] + K[0];
     E = D;
     D = C;
     C = SHA1CircularShift(30,B);
     B = A;
     A = temp;
   }
-  
+
   for (t = 20; t < 40; t++)
   {
     temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[1];
@@ -343,8 +294,8 @@ void SHA1ProcessMessageBlock(SHA1_CONTEXT *context)
 
   for (t = 40; t < 60; t++)
   {
-    temp = SHA1CircularShift(5,A) +
-           ((B & C) | (B & D) | (C & D)) + E + W[t] + K[2];
+    temp= (SHA1CircularShift(5,A) + ((B & C) | (B & D) | (C & D)) + E + W[t] +
+	   K[2]);
     E = D;
     D = C;
     C = SHA1CircularShift(30,B);
@@ -367,73 +318,67 @@ void SHA1ProcessMessageBlock(SHA1_CONTEXT *context)
   context->Intermediate_Hash[2] += C;
   context->Intermediate_Hash[3] += D;
   context->Intermediate_Hash[4] += E;
-  
+
   context->Message_Block_Index = 0;
 }
 
 
 /*
-   SHA1PadMessage
- 
-
-   Description:
-       According to the standard, the message must be padded to an even
-       512 bits.  The first padding bit must be a '1'.  The last 64
-       bits represent the length of the original message.  All bits in
-       between should be 0.  This function will pad the message
-       according to those rules by filling the Message_Block array
-       accordingly.  It will also call the ProcessMessageBlock function
-       provided appropriately.  When it returns, it can be assumed that
-       the message digest has been computed.
- 
-   Parameters:
-       context: [in/out]
-           The context to pad
-       ProcessMessageBlock: [in]
-           The appropriate SHA*ProcessMessageBlock function
-   Returns:
-       Nothing.
- 
+  Pad message
+
+  SYNOPSIS
+    SHA1PadMessage()
+    context: [in/out]		The context to pad
+
+  DESCRIPTION
+    According to the standard, the message must be padded to an even
+    512 bits.  The first padding bit must be a '1'. The last 64 bits
+    represent the length of the original message.  All bits in between
+    should be 0.  This function will pad the message according to
+    those rules by filling the Message_Block array accordingly.  It
+    will also call the ProcessMessageBlock function provided
+    appropriately. When it returns, it can be assumed that the message
+    digest has been computed.
+
 */
 
 void SHA1PadMessage(SHA1_CONTEXT *context)
 {
   /*
-   Check to see if the current message block is too small to hold
-   the initial padding bits and length.  If so, we will pad the
-   block, process it, and then continue padding into a second
-   block.
+    Check to see if the current message block is too small to hold
+    the initial padding bits and length.  If so, we will pad the
+    block, process it, and then continue padding into a second
+    block.
   */
-  
+
   int i=context->Message_Block_Index;
 
   if (i > 55)
   {
     context->Message_Block[i++] = 0x80;
     bzero((char*) &context->Message_Block[i],
-          sizeof(context->Message_Block[0])*(64-i));
+	  sizeof(context->Message_Block[0])*(64-i));
     context->Message_Block_Index=64;
-    
-    /* This function sets context->Message_Block_Index to zero  */
-    SHA1ProcessMessageBlock(context);    
+
+    /* This function sets context->Message_Block_Index to zero	*/
+    SHA1ProcessMessageBlock(context);
 
     bzero((char*) &context->Message_Block[0],
-          sizeof(context->Message_Block[0])*56);
+	  sizeof(context->Message_Block[0])*56);
     context->Message_Block_Index=56;
-    
-  }  
+  }
   else
   {
     context->Message_Block[i++] = 0x80;
     bzero((char*) &context->Message_Block[i],
-          sizeof(context->Message_Block[0])*(56-i));
+	  sizeof(context->Message_Block[0])*(56-i));
     context->Message_Block_Index=56;
   }
-            
+
   /*
-   Store the message length as the last 8 octets
+    Store the message length as the last 8 octets
   */
-  
+
   context->Message_Block[56] = context->Length >> 56;
   context->Message_Block[57] = context->Length >> 48;
   context->Message_Block[58] = context->Length >> 40;
@@ -445,4 +390,3 @@ void SHA1PadMessage(SHA1_CONTEXT *context)
 
   SHA1ProcessMessageBlock(context);
 }
-