SCRAM Remove spaces from most changed files.

This alters not only my code so it looks like I'm not only one adding the spaces.



client/mysqladmin.c:
  cut spaces
include/mysql_com.h:
  cut soaces
sql/item_strfunc.cc:
  cut spaces
sql/mini_client.cc:
  cut spaces
sql/mysql_priv.h:
  cut spaces
sql/mysqld.cc:
  cut spaces
sql/password.c:
  cut spaces
sql/sql_parse.cc:
  cut spaces
sql/sql_yacc.yy:
  cut spaces

1 files changed, 119 insertions, 119 deletions

diff --git a/sql/password.c b/sql/password.c
index 7a3831d67b7..6f1557bbd34 100644
--- a/sql/password.c
+++ b/sql/password.c
@@ -32,26 +32,26 @@
   Example:
     update user set password=PASSWORD("hello") where user="test"
   This saves a hashed number as a string in the password field.
-  
-  
+
+
   New in MySQL 4.1 authentication works even more secure way.
-  At the first step client sends user name to the sever, and password if 
+  At the first step client sends user name to the sever, and password if
   it is empty. So in case of empty password authentication is as fast as before.
   At the second stap servers sends scramble to client, which is encoded with
-  password stage2 hash stored in the password  database as well as salt, needed 
-  for client to build stage2 password to decrypt scramble.  
+  password stage2 hash stored in the password  database as well as salt, needed
+  for client to build stage2 password to decrypt scramble.
   Client decrypts the scramble and encrypts it once again with stage1 password.
   This information is sent to server.
-  Server decrypts the scramble to get stage1 password and hashes it to get 
+  Server decrypts the scramble to get stage1 password and hashes it to get
   stage2 hash. This hash is when compared to hash stored in the database.
-  
-  This authentication needs 2 packet round trips instead of one but it is much 
-  stronger. Now if one will steal mysql database content he will not be able 
+
+  This authentication needs 2 packet round trips instead of one but it is much
+  stronger. Now if one will steal mysql database content he will not be able
   to break into MySQL.
 
   New Password handling functions by Peter Zaitsev
-  
-  
+
+
 *****************************************************************************/
 
 #include <my_global.h>
@@ -70,17 +70,17 @@
 
 /*
   New (MySQL 3.21+) random generation structure initialization
-  
+
   SYNOPSIS
     randominit()
     rand_st    OUT  Structure to initialize
     seed1      IN   First initialization parameter
     seed2      IN   Second initialization parameter
-                                  
+
   RETURN
     none
 */
-                                            
+
 void randominit(struct rand_struct *rand_st,ulong seed1, ulong seed2)
 {						/* For mysql 3.21.# */
 #ifdef HAVE_purify
@@ -95,12 +95,12 @@ void randominit(struct rand_struct *rand_st,ulong seed1, ulong seed2)
 
 /*
   Old (MySQL 3.20) random generation structure initialization
-  
+
   SYNOPSIS
     old_randominit()
     rand_st    OUT  Structure to initialize
     seed1      IN   First initialization parameter
-                                  
+
   RETURN
     none
 */
@@ -116,11 +116,11 @@ static void old_randominit(struct rand_struct *rand_st,ulong seed1)
 
 /*
   Generate Random number
-  
+
   SYNOPSIS
     rnd()
     rand_st    INOUT  Structure used for number generation
-                                  
+
   RETURN
     Generated pseudo random number
 */
@@ -136,13 +136,13 @@ double rnd(struct rand_struct *rand_st)
 /*
   Generate String of printable random characters of requested length
   String will not be zero terminated.
-  
+
   SYNOPSIS
     create_random_string()
-    length     IN     Lenght of 
+    length     IN     Lenght of
     rand_st    INOUT  Structure used for number generation
     target     OUT    Buffer for generation
-                                  
+
   RETURN
     none
 */
@@ -153,7 +153,7 @@ void create_random_string(int length,struct rand_struct *rand_st,char* target)
   /* Use pointer arithmetics as it is faster way to do so. */
   while (target<end)
   {
-    *target=rnd(rand_st)*94+33; 
+    *target=rnd(rand_st)*94+33;
     target++;
   }
 }
@@ -162,22 +162,22 @@ void create_random_string(int length,struct rand_struct *rand_st,char* target)
 /*
   Encrypt/Decrypt function used for password encryption in authentication
   Simple XOR is used here but it is OK as we crypt random strings
-  
+
   SYNOPSIS
     password_crypt()
     from     IN     Data for encryption
     to       OUT    Encrypt data to the buffer (may be the same)
-    password IN     Password used for encryption (same length) 
+    password IN     Password used for encryption (same length)
     length   IN     Length of data to encrypt
-                                  
+
   RETURN
     none
 */
 
-void password_crypt(const char* from,char* to, const char* password,int length) 
+void password_crypt(const char* from,char* to, const char* password,int length)
 {
  const char *from_end=from+length;
- 
+
  while (from < from_end)
    *to++= *(from++) ^* (password++);
 }
@@ -186,12 +186,12 @@ void password_crypt(const char* from,char* to, const char* password,int length)
 /*
   Generate binary hash from raw text password
   Used for Pre-4.1 Password handling
-  
+
   SYNOPSIS
     hash_pasword()
     result   OUT    Store hash in this location
     password IN     Plain text password to build hash
-                                  
+
   RETURN
     none
 */
@@ -216,66 +216,66 @@ void hash_password(ulong *result, const char *password)
 
 
 /*
-  Stage one password hashing. 
+  Stage one password hashing.
   Used in MySQL 4.1 password handling
-  
+
   SYNOPSIS
     password_hash_stage1()
     to       OUT    Store stage one hash to this location
     password IN     Plain text password to build hash
-                                  
+
   RETURN
     none
 */
 
 void password_hash_stage1(char *to, const char *password)
 {
-  SHA1_CONTEXT context; 
+  SHA1_CONTEXT context;
   sha1_reset(&context);
   for (; *password ; password++)
   {
-    if (*password == ' ' || *password == '\t') 
+    if (*password == ' ' || *password == '\t')
       continue;/* skip space in password */
-    sha1_input(&context,(int8*)&password[0],1);	
+    sha1_input(&context,(int8*)&password[0],1);
   }
-  sha1_result(&context,(uint8*)to);    
+  sha1_result(&context,(uint8*)to);
 }
 
 
 /*
-  Stage two password hashing. 
+  Stage two password hashing.
   Used in MySQL 4.1 password handling
-  
+
   SYNOPSIS
     password_hash_stage2()
     to       INOUT  Use this as stage one hash and store stage two hash here
     salt     IN     Salt used for stage two hashing
-                                  
+
   RETURN
     none
 */
 
 void password_hash_stage2(char *to,const char *salt)
 {
-  SHA1_CONTEXT context;     
+  SHA1_CONTEXT context;
   sha1_reset(&context);
   sha1_input(&context,(uint8*)salt,4);
   sha1_input(&context,to,SHA1_HASH_SIZE);
-  sha1_result(&context,(uint8*)to);    
+  sha1_result(&context,(uint8*)to);
 }
 
 
 /*
   Create password to be stored in user database from raw string
-  Handles both MySQL 4.1 and Pre-MySQL 4.1 passwords 
-  
+  Handles both MySQL 4.1 and Pre-MySQL 4.1 passwords
+
   SYNOPSIS
     make_scramble_password()
-    to       OUT   Store scrambled password here 
+    to       OUT   Store scrambled password here
     password IN    Raw string password
-    force_old_scramle 
+    force_old_scramle
              IN    Force generation of old scramble variant
-    rand_st  INOUT Structure for temporary number generation.                              
+    rand_st  INOUT Structure for temporary number generation.
   RETURN
     none
 */
@@ -283,7 +283,7 @@ void password_hash_stage2(char *to,const char *salt)
 void make_scrambled_password(char *to,const char *password,
                              my_bool force_old_scramble,
                              struct rand_struct *rand_st)
-{ 
+{
   ulong hash_res[2];   /* Used for pre 4.1 password hashing */
   unsigned short salt; /* Salt for 4.1 version password */
   uint8 digest[SHA1_HASH_SIZE];
@@ -292,37 +292,37 @@ void make_scrambled_password(char *to,const char *password,
     hash_password(hash_res,password);
     sprintf(to,"%08lx%08lx",hash_res[0],hash_res[1]);
   }
-  else /* New password 4.1 password scrambling */ 
+  else /* New password 4.1 password scrambling */
   {
     to[0]=PVERSION41_CHAR; /* New passwords have version prefix */
    /* Random returns number from 0 to 1 so this would be good salt generation.*/
-    salt=rnd(rand_st)*65535+1; 
-    /* Use only 2 first bytes from it */ 
+    salt=rnd(rand_st)*65535+1;
+    /* Use only 2 first bytes from it */
     sprintf(to+1,"%04x",salt);
     /* First hasing is done without salt */
     password_hash_stage1(digest,password);
     /* Second stage is done with salt */
-    password_hash_stage2(digest,(char*)to+1),    
+    password_hash_stage2(digest,(char*)to+1),
     /* Print resulting hash into the password*/
     sprintf(to+5,
       "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
       digest[0],digest[1],digest[2],digest[3],digest[4],digest[5],digest[6],
       digest[7],digest[8],digest[9],digest[10],digest[11],digest[12],digest[13],
-      digest[14],digest[15],digest[16],digest[17],digest[18],digest[19]);         
+      digest[14],digest[15],digest[16],digest[17],digest[18],digest[19]);
   }
 }
 
 
 /*
-  Convert password from binary string form to salt form 
+  Convert password from binary string form to salt form
   Used for MySQL 4.1 password handling
-  
+
   SYNOPSIS
     get_salt_from_bin_password()
     res      OUT Store salt form password here
     password IN  Binary password to be converted
     salt     IN  hashing-salt to be used for salt form generation
-                                  
+
   RETURN
     none
 */
@@ -332,7 +332,7 @@ void get_salt_from_bin_password(ulong *res,unsigned char *password,ulong salt)
   unsigned char* password_end=password+SCRAMBLE41_LENGTH;
   *res=salt;
   res++;
-  
+
   /* Process password of known length*/
   while (password<password_end)
   {
@@ -341,19 +341,19 @@ void get_salt_from_bin_password(ulong *res,unsigned char *password,ulong salt)
     for (i=0 ; i < 4 ; i++)
        val=(val << 8)+(*password++);
     *res++=val;
-  }    
+  }
 }
 
 
 /*
-  Validate password for MySQL 4.1 password handling. 
-  
+  Validate password for MySQL 4.1 password handling.
+
   SYNOPSIS
     validate_password()
     password IN   Encrypted Scramble which we got from the client
     message  IN   Original scramble which we have sent to the client before
-    salt     IN   Password in the salted form to match to 
-                                  
+    salt     IN   Password in the salted form to match to
+
   RETURN
     0 for correct password
    !0 for invalid password
@@ -367,34 +367,34 @@ my_bool validate_password(const char* password, const char* message,
   ulong salt_candidate[6]; /* Computed candidate salt */
   ulong* sc=salt_candidate; /* we need to be able to increment */
   ulong* salt_end;
-  
+
   /* Now we shall get stage1 encrypted password in buffer*/
   password_crypt(password,buffer,message,SCRAMBLE41_LENGTH);
-  
+
   /* For compatibility reasons we use ulong to store salt while we need char */
   sprintf(tmpsalt,"%04x",(unsigned short)salt[0]);
-  
+
   password_hash_stage2(buffer,tmpsalt);
   /* Convert password to salt to compare */
   get_salt_from_bin_password(salt_candidate,buffer,salt[0]);
-  
-  /* Now we shall get exactly the same password as we have stored for user  */ 
+
+  /* Now we shall get exactly the same password as we have stored for user  */
   for (salt_end=salt+5 ; salt < salt_end; )
     if (*++salt != *++sc)
       return 1;
-  
-  /* Or password correct*/    
+
+  /* Or password correct*/
   return 0;
-} 
+}
 
 
 /*
   Get length of password string which is stored in mysql.user table
-  
+
   SYNOPSIS
     get_password_length()
-    force_old_scramble  IN  If we wish to use pre 4.1 scramble format     
-                                  
+    force_old_scramble  IN  If we wish to use pre 4.1 scramble format
+
   RETURN
     password length >0
 */
@@ -407,11 +407,11 @@ int get_password_length(my_bool force_old_scramble)
 
 /*
   Get version of the password based on mysql.user password string
-  
+
   SYNOPSIS
     get_password_version()
     password IN   Password string as stored in mysql.user
-                                  
+
   RETURN
     0 for pre 4.1 passwords
    !0 password version char for newer passwords
@@ -419,19 +419,19 @@ int get_password_length(my_bool force_old_scramble)
 
 char get_password_version(const char* password)
 {
-  if (password==NULL) return 0; 
+  if (password==NULL) return 0;
   if (password[0]==PVERSION41_CHAR) return PVERSION41_CHAR;
   return 0;
 }
 
 
 /*
-  Get integer value of Hex character 
-  
+  Get integer value of Hex character
+
   SYNOPSIS
     char_val()
     X        IN   Character to find value for
-                                  
+
   RETURN
     Appropriate integer value
 */
@@ -448,18 +448,18 @@ inline uint char_val(char X)
 
 /*
   Get Binary salt from password as in mysql.user format
-  
+
   SYNOPSIS
     get_salt_from_password()
     res      OUT  Store binary salt here
     password IN   Password string as stored in mysql.user
-                                  
+
   RETURN
     none
-    
+
   NOTE
     This function does not have length check for passwords. It will just crash
-    Password hashes in old format must have length divisible by 8     
+    Password hashes in old format must have length divisible by 8
 */
 
 void get_salt_from_password(ulong *res,const char *password)
@@ -471,18 +471,18 @@ void get_salt_from_password(ulong *res,const char *password)
       uint val=0;
       uint i;
       password++; /* skip version identifier */
-      
+
       /*get hashing salt from password and store in in the start of array */
       for (i=0 ; i < 4 ; i++)
 	val=(val << 4)+char_val(*password++);
-      *res++=val; 
+      *res++=val;
     }
      /* We process old passwords the same way as new ones in other case */
 #ifdef EXTRA_DEBUG
     if (strlen(password)%8!=0)
       fprintf(stderr,"Warning: Incorrect password length for salting: %d\n",
-              strlen(password)); 
-#endif     
+              strlen(password));
+#endif
     while (*password)
     {
       ulong val=0;
@@ -490,7 +490,7 @@ void get_salt_from_password(ulong *res,const char *password)
       for (i=0 ; i < 8 ; i++)
 	val=(val << 4)+char_val(*password++);
       *res++=val;
-    }    
+    }
   }
   return;
 }
@@ -498,14 +498,14 @@ void get_salt_from_password(ulong *res,const char *password)
 
 /*
   Get string version as stored in mysql.user from salt form
-  
+
   SYNOPSIS
     make_password_from_salt()
     to       OUT  Store resulting string password here
     hash_res IN   Password in salt format
     password_version
              IN   According to which version salt should be treated
-                                  
+
   RETURN
     none
 */
@@ -526,14 +526,14 @@ void make_password_from_salt(char *to, ulong *hash_res,uint8 password_version)
 /*
   Convert password in salted form to binary string password and hash-salt
   For old password this involes one more hashing
-  
+
   SYNOPSIS
     get_hash_and_password()
     salt         IN  Salt to convert from
     pversion     IN  Password version to use
-    hash         OUT Store zero ended hash here 
+    hash         OUT Store zero ended hash here
     bin_password OUT Store binary password here (no zero at the end)
-                                  
+
   RETURN
     0 for pre 4.1 passwords
    !0 password version char for newer passwords
@@ -544,9 +544,9 @@ void get_hash_and_password(ulong* salt, uint8 pversion, char* hash, unsigned cha
   int t;
   ulong* salt_end;
   ulong val;
-  SHA1_CONTEXT context; 
+  SHA1_CONTEXT context;
   unsigned char* bp; /* Binary password loop pointer */
-  
+
   if (pversion) /* New password version assumed */
   {
     salt_end=salt+5;
@@ -559,13 +559,13 @@ void get_hash_and_password(ulong* salt, uint8 pversion, char* hash, unsigned cha
         bin_password[t]=val%256;
         val>>=8; /* Scroll 8 bits to get next part*/
       }
-      bin_password+=4; /* Get to next 4 chars*/ 
+      bin_password+=4; /* Get to next 4 chars*/
     }
   }
-  else 
+  else
   {
     /* Use zero starting hash as an indication of old password */
-    hash[0]=0; 
+    hash[0]=0;
     salt_end=salt+2;
     bp=bin_password;
     /* Encode salt using SHA1 here */
@@ -576,28 +576,28 @@ void get_hash_and_password(ulong* salt, uint8 pversion, char* hash, unsigned cha
       for(t=3;t>=0;t--)
       {
         bp[t]=val%256;
-        
+
         val>>=8; /* Scroll 8 bits to get next part*/
       }
-      bp+=4; /* Get to next 4 chars*/ 
+      bp+=4; /* Get to next 4 chars*/
       salt++;
     }
     /* Use 8 bytes of binary password for hash */
-    sha1_input(&context,(uint8*)bin_password,8);	
-    sha1_result(&context,(uint8*)bin_password);    
-  }    
+    sha1_input(&context,(uint8*)bin_password,8);
+    sha1_result(&context,(uint8*)bin_password);
+  }
 }
 
 
 /*
-  Create key from old password to decode scramble  
+  Create key from old password to decode scramble
   Used in 4.1 authentication with passwords stored old way
-  
+
   SYNOPSIS
     create_key_from_old_password()
     passwd    IN  Password used for key generation
-    key       OUT Created 20 bytes key 
-                                  
+    key       OUT Created 20 bytes key
+
   RETURN
     None
 */
@@ -615,35 +615,35 @@ void create_key_from_old_password(const char* passwd, char* key)
   get_hash_and_password(salt,0,buffer,(unsigned char*) key);
 }
 
- 
+
 /*
-  Scramble string with password 
+  Scramble string with password
   Used at pre 4.1 authentication phase.
-  
+
   SYNOPSIS
     scramble()
     to        OUT Store scrambled message here
     message   IN  Message to scramble
     password  IN  Password to use while scrambling
     old_ver   IN  Forse old version random number generator
-                                  
+
   RETURN
     End of scrambled string
 */
- 
+
 char *scramble(char *to,const char *message,const char *password,
 	       my_bool old_ver)
 {
   struct rand_struct rand_st;
   ulong hash_pass[2],hash_message[2];
   char message_buffer[9]; /* Real message buffer */
-  char* msg=message_buffer;  
-  
+  char* msg=message_buffer;
+
   /* We use special message buffer now as new server can provide longer hash */
-  
+
   memcpy(message_buffer,message,8);
   message_buffer[8]=0;
-  
+
   if (password && password[0])
   {
     char *to_start=to;
@@ -669,16 +669,16 @@ char *scramble(char *to,const char *message,const char *password,
 
 
 /*
-  Check scrambled message 
+  Check scrambled message
   Used for pre 4.1 password handling
-  
+
   SYNOPSIS
     scramble()
     scrambled IN  Scrambled message to check
     message   IN  Original message which was scramble
     hash_pass IN  Password which should be used for scrambling
     old_ver   IN  Forse old version random number generator
-                                  
+
   RETURN
     0  Password correct
    !0  Password invalid
@@ -695,7 +695,7 @@ my_bool check_scramble(const char *scrambled, const char *message,
 
   memcpy(message_buffer,message,8); /* Old auth uses 8 bytes at maximum */
   message_buffer[8]=0;
-  
+
   hash_password(hash_message,message_buffer);
   if (old_ver)
     old_randominit(&rand_st,hash_pass[0] ^ hash_message[0]);