Merge bk-internal.mysql.com:/data0/bk/mysql-5.1-new

into  bk-internal.mysql.com:/data0/bk/mysql-5.1-kt


include/m_string.h:
  Auto merged
include/my_sys.h:
  Auto merged
mysql-test/mysql-test-run.pl:
  Auto merged
sql/log.cc:
  Auto merged
sql/mysqld.cc:
  Auto merged
sql/set_var.cc:
  Auto merged
sql/sql_class.cc:
  Auto merged
sql/sql_class.h:
  Auto merged
sql/sql_parse.cc:
  Auto merged
sql/share/errmsg.txt:
  C
  Merged.
  ?

.bzrignore

@@ -1770,3 +1770,4 @@ vio/viotest-sslconnect.cpp
 vio/viotest.cpp
 zlib/*.ds?
 zlib/*.vcproj
+libmysqld/event_scheduler.cc

client/get_password.c

@@ -64,7 +64,7 @@
 /* were just going to fake it here and get input from
    the keyboard */
 
-char *get_tty_password(char *opt_message)
+char *get_tty_password(const char *opt_message)
 {
   char to[80];
   char *pos=to,*end=to+sizeof(to)-1;
@@ -150,7 +150,7 @@ static void get_password(char *to,uint length,int fd,bool echo)
 #endif /* ! HAVE_GETPASS */
 
 
-char *get_tty_password(char *opt_message)
+char *get_tty_password(const char *opt_message)
 {
 #ifdef HAVE_GETPASS
   char *passbuff;

configure.in

@@ -7,7 +7,7 @@ AC_INIT(sql/mysqld.cc)
 AC_CANONICAL_SYSTEM
 # The Docs Makefile.am parses this line!
 # remember to also change ndb version below and update version.c in ndb
-AM_INIT_AUTOMAKE(mysql, 5.1.11-beta)
+AM_INIT_AUTOMAKE(mysql, 5.1.12-beta)
 AM_CONFIG_HEADER(config.h)
 
 PROTOCOL_VERSION=10

extra/yassl/examples/echoserver/echoserver.cpp

@@ -65,7 +65,8 @@ THREAD_RETURN YASSL_API echoserver_test(void* args)
     while (!shutdown) {
         sockaddr_in client;
         socklen_t   client_len = sizeof(client);
-        int         clientfd = accept(sockfd, (sockaddr*)&client, &client_len);
+        int         clientfd = accept(sockfd, (sockaddr*)&client,
+                                      (ACCEPT_THIRD_T)&client_len);
         if (clientfd == -1) err_sys("tcp accept failed");
 
         SSL* ssl = SSL_new(ctx);

extra/yassl/include/openssl/ssl.h

@@ -273,6 +273,7 @@ int SSL_pending(SSL*);
 
 
 enum { /* ssl Constants */
+    SSL_WOULD_BLOCK     = -8,
     SSL_BAD_STAT        = -7,
     SSL_BAD_PATH        = -6,
     SSL_BAD_FILETYPE    = -5,
@@ -494,7 +495,7 @@ ASN1_TIME* X509_get_notAfter(X509* x);
 
 
 typedef struct MD4_CTX {
-    void* ptr;
+    int buffer[32];      /* big enough to hold, check size in Init */
 } MD4_CTX;
 
 void MD4_Init(MD4_CTX*);

extra/yassl/include/socket_wrapper.hpp

@@ -66,6 +66,7 @@ typedef unsigned char byte;
 // Wraps Windows Sockets and BSD Sockets
 class Socket {
     socket_t socket_;                    // underlying socket descriptor
+    bool     wouldBlock_;                // for non-blocking data
 public:
     explicit Socket(socket_t s = INVALID_SOCKET);
     ~Socket();
@@ -75,9 +76,10 @@ public:
     socket_t get_fd()    const;
 
     uint send(const byte* buf, unsigned int len, int flags = 0) const;
-    uint receive(byte* buf, unsigned int len, int flags = 0)    const;
+    uint receive(byte* buf, unsigned int len, int flags = 0);
 
-    bool wait() const;
+    bool wait();
+    bool WouldBlock() const;
 
     void closeSocket();
     void shutDown(int how = SD_SEND);

extra/yassl/mySTL/stdexcept.hpp

@@ -46,8 +46,10 @@ public:
     // for compiler generated call, never used
     static void operator delete(void*) { assert(0); }
 private:
+#if defined(__hpux)
     // don't allow dynamic creation of exceptions
     static void* operator new(size_t);
+#endif
 };
 
 

extra/yassl/src/handshake.cpp

@@ -656,7 +656,7 @@ mySTL::auto_ptr<input_buffer>
 DoProcessReply(SSL& ssl, mySTL::auto_ptr<input_buffer> buffered)
 {
     // wait for input if blocking
-    if (!ssl.getSocket().wait()) {
+    if (!ssl.useSocket().wait()) {
       ssl.SetError(receive_error);
         buffered.reset(0);
         return buffered;
@@ -673,7 +673,7 @@ DoProcessReply(SSL& ssl, mySTL::auto_ptr<input_buffer> buffered)
     }
 
     // add new data
-    uint read  = ssl.getSocket().receive(buffer.get_buffer() + buffSz, ready);
+    uint read  = ssl.useSocket().receive(buffer.get_buffer() + buffSz, ready);
     buffer.add_size(read);
     uint offset = 0;
     const MessageFactory& mf = ssl.getFactory().getMessage();
@@ -858,6 +858,9 @@ void sendFinished(SSL& ssl, ConnectionEnd side, BufferOutput buffer)
 // send data
 int sendData(SSL& ssl, const void* buffer, int sz)
 {
+    if (ssl.GetError() == YasslError(SSL_ERROR_WANT_READ))
+        ssl.SetError(no_error);
+
     ssl.verfiyHandShakeComplete();
     if (ssl.GetError()) return 0;
     int sent = 0;
@@ -893,6 +896,9 @@ int sendAlert(SSL& ssl, const Alert& alert)
 // process input data
 int receiveData(SSL& ssl, Data& data)
 {
+    if (ssl.GetError() == YasslError(SSL_ERROR_WANT_READ))
+        ssl.SetError(no_error);
+
     ssl.verfiyHandShakeComplete();
     if (ssl.GetError()) return 0;
 
@@ -902,6 +908,11 @@ int receiveData(SSL& ssl, Data& data)
     ssl.useLog().ShowData(data.get_length());
 
     if (ssl.GetError()) return 0;
+
+    if (data.get_length() == 0 && ssl.getSocket().WouldBlock()) {
+        ssl.SetError(YasslError(SSL_ERROR_WANT_READ));
+        return SSL_WOULD_BLOCK;
+    }
     return data.get_length(); 
 }
 

extra/yassl/src/socket_wrapper.cpp

@@ -58,7 +58,7 @@ namespace yaSSL {
 
 
 Socket::Socket(socket_t s) 
-    : socket_(s) 
+    : socket_(s), wouldBlock_(false)
 {}
 
 
@@ -123,17 +123,21 @@ uint Socket::send(const byte* buf, unsigned int sz, int flags) const
 }
 
 
-uint Socket::receive(byte* buf, unsigned int sz, int flags) const
+uint Socket::receive(byte* buf, unsigned int sz, int flags)
 {
     assert(socket_ != INVALID_SOCKET);
+    wouldBlock_ = false;
+
     int recvd = ::recv(socket_, reinterpret_cast<char *>(buf), sz, flags);
 
     // idea to seperate error from would block by arnetheduck@gmail.com
     if (recvd == -1) {
         if (get_lastError() == SOCKET_EWOULDBLOCK || 
-            get_lastError() == SOCKET_EAGAIN)
+            get_lastError() == SOCKET_EAGAIN) {
+            wouldBlock_ = true;
         return 0;
     }
+    }
     else if (recvd == 0)
         return static_cast<uint>(-1);
 
@@ -142,7 +146,7 @@ uint Socket::receive(byte* buf, unsigned int sz, int flags) const
 
 
 // wait if blocking for input, return false for error
-bool Socket::wait() const
+bool Socket::wait()
 {
     byte b;
     return receive(&b, 1, MSG_PEEK) != static_cast<uint>(-1);
@@ -166,6 +170,12 @@ int Socket::get_lastError()
 }
 
 
+bool Socket::WouldBlock() const
+{
+    return wouldBlock_;
+}
+
+
 void Socket::set_lastError(int errorCode)
 {
 #ifdef _WIN32

extra/yassl/src/ssl.cpp

@@ -37,6 +37,7 @@
 #include "handshake.hpp"
 #include "yassl_int.hpp"
 #include "md5.hpp"              // for TaoCrypt MD5 size assert
+#include "md4.hpp"              // for TaoCrypt MD4 size assert
 #include <stdio.h>
 
 #ifdef _WIN32
@@ -1131,17 +1132,26 @@ void* X509_get_ext_d2i(X509* x, int nid, int* crit, int* idx)
 
 void MD4_Init(MD4_CTX* md4)
 {
-    assert(0);  // not yet supported, build compat. only
+    // make sure we have a big enough buffer
+    typedef char ok[sizeof(md4->buffer) >= sizeof(TaoCrypt::MD4) ? 1 : -1];
+    (void) sizeof(ok);
+
+    // using TaoCrypt since no dynamic memory allocated
+    // and no destructor will be called
+    new (reinterpret_cast<yassl_pointer>(md4->buffer)) TaoCrypt::MD4();
 }
 
 
 void MD4_Update(MD4_CTX* md4, const void* data, unsigned long sz)
 {
+    reinterpret_cast<TaoCrypt::MD4*>(md4->buffer)->Update(
+                static_cast<const byte*>(data), static_cast<unsigned int>(sz));
 }
 
 
 void MD4_Final(unsigned char* hash, MD4_CTX* md4)
 {
+    reinterpret_cast<TaoCrypt::MD4*>(md4->buffer)->Final(hash);
 }
 
 

extra/yassl/src/template_instnt.cpp

@@ -31,6 +31,7 @@
 #include "hmac.hpp"
 #include "md5.hpp"
 #include "sha.hpp"
+#include "ripemd.hpp"
 #include "openssl/ssl.h"
 
 #ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION

extra/yassl/src/timer.cpp

@@ -26,13 +26,17 @@
 #include "runtime.hpp"
 #include "timer.hpp"
 
+#ifdef _WIN32
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#else
+#include <sys/time.h>
+#endif
+
 namespace yaSSL {
 
 #ifdef _WIN32
 
-    #define WIN32_LEAN_AND_MEAN
-    #include <windows.h>
-
     timer_d timer()
     {
         static bool          init(false);
@@ -57,8 +61,6 @@ namespace yaSSL {
 
 #else // _WIN32
 
-    #include <sys/time.h>
-
     timer_d timer()
     {
         struct timeval tv;

extra/yassl/src/yassl_error.cpp

@@ -26,6 +26,7 @@
 #include "runtime.hpp"
 #include "yassl_error.hpp"
 #include "error.hpp"        // TaoCrypt error numbers
+#include "openssl/ssl.h"    // SSL_ERROR_WANT_READ
 
 namespace yaSSL {
 
@@ -117,6 +118,11 @@ void SetErrorString(YasslError error, char* buffer)
         strncpy(buffer, "unable to proccess cerificate", max);
         break; 
 
+        // openssl errors
+    case SSL_ERROR_WANT_READ :
+        strncpy(buffer, "the read operation would block", max);
+        break;
+
         // TaoCrypt errors
     case NO_ERROR :
         strncpy(buffer, "not in error state", max);

extra/yassl/src/yassl_int.cpp

@@ -1415,15 +1415,6 @@ BulkCipher* CryptProvider::NewDesEde()
 }
 
 
-extern "C" void yaSSL_CleanUp()
-{
-    TaoCrypt::CleanUp();
-    ysDelete(cryptProviderInstance);
-    ysDelete(sslFactoryInstance);
-    ysDelete(sessionsInstance);
-}
-
-
 typedef Mutex::Lock Lock;
 
  
@@ -2109,9 +2100,18 @@ ASN1_STRING* StringHolder::GetString()
 }
 
 
-
 } // namespace
 
+
+extern "C" void yaSSL_CleanUp()
+{
+    TaoCrypt::CleanUp();
+    ysDelete(yaSSL::cryptProviderInstance);
+    ysDelete(yaSSL::sslFactoryInstance);
+    ysDelete(yaSSL::sessionsInstance);
+}
+
+
 #ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
 namespace mySTL {
 template yaSSL::yassl_int_cpp_local1::SumData for_each<mySTL::list<yaSSL::input_buffer*>::iterator, yaSSL::yassl_int_cpp_local1::SumData>(mySTL::list<yaSSL::input_buffer*>::iterator, mySTL::list<yaSSL::input_buffer*>::iterator, yaSSL::yassl_int_cpp_local1::SumData);

extra/yassl/taocrypt/CMakeLists.txt

@@ -2,7 +2,7 @@ INCLUDE_DIRECTORIES(../mySTL include)
 
 ADD_LIBRARY(taocrypt src/aes.cpp src/aestables.cpp src/algebra.cpp src/arc4.cpp src/asn.cpp src/coding.cpp 
 				src/des.cpp src/dh.cpp src/dsa.cpp src/file.cpp src/hash.cpp src/integer.cpp src/md2.cpp 
-				src/md5.cpp src/misc.cpp src/random.cpp src/ripemd.cpp src/rsa.cpp src/sha.cpp
+				src/md4.cpp src/md5.cpp src/misc.cpp src/random.cpp src/ripemd.cpp src/rsa.cpp src/sha.cpp
 				include/aes.hpp include/algebra.hpp include/arc4.hpp include/asn.hpp include/block.hpp 
 				include/coding.hpp include/des.hpp include/dh.hpp include/dsa.hpp include/dsa.hpp
 				include/error.hpp include/file.hpp include/hash.hpp include/hmac.hpp include/integer.hpp 

extra/yassl/taocrypt/include/block.hpp

@@ -96,7 +96,7 @@ public:
 
     pointer allocate(size_type n, const void* = 0)
     {
-        CheckSize(n);
+        this->CheckSize(n);
         if (n == 0)
             return 0;
         return NEW_TC T[n];

extra/yassl/taocrypt/include/md4.hpp

+/* md4.hpp                                
+ *
+ * Copyright (C) 2003 Sawtooth Consulting Ltd.
+ *
+ * This file is part of yaSSL.
+ *
+ * yaSSL is free software; you can redistribute it and/or modify
+ * 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.
+ *
+ * yaSSL 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
+ */
+
+/* md4.hpp provides MD4 digest support
+ * WANRING: MD4 is considered insecure, only use if you have to, e.g., yaSSL
+ * libcurl supports needs this for NTLM authentication
+*/
+
+#ifndef TAO_CRYPT_MD4_HPP
+#define TAO_CRYPT_MD4_HPP
+
+#include "hash.hpp"
+
+namespace TaoCrypt {
+
+
+// MD4 digest
+class MD4 : public HASHwithTransform {
+public:
+    enum { BLOCK_SIZE = 64, DIGEST_SIZE = 16, PAD_SIZE = 56,
+           TAO_BYTE_ORDER = LittleEndianOrder };   // in Bytes
+    MD4() : HASHwithTransform(DIGEST_SIZE / sizeof(word32), BLOCK_SIZE) 
+                { Init(); }
+    ByteOrder getByteOrder()  const { return ByteOrder(TAO_BYTE_ORDER); }
+    word32    getBlockSize()  const { return BLOCK_SIZE; }
+    word32    getDigestSize() const { return DIGEST_SIZE; }
+    word32    getPadSize()    const { return PAD_SIZE; }
+
+    MD4(const MD4&);
+    MD4& operator= (const MD4&);
+
+    void Init();
+    void Swap(MD4&);
+private:
+    void Transform();
+};
+
+inline void swap(MD4& a, MD4& b)
+{
+    a.Swap(b);
+}
+
+
+} // namespace
+
+#endif // TAO_CRYPT_MD4_HPP
+

extra/yassl/taocrypt/include/runtime.hpp

@@ -28,10 +28,6 @@
 #ifndef yaSSL_NEW_HPP
 #define yaSSL_NEW_HPP
 
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
 
 #ifdef __sun
  

extra/yassl/taocrypt/src/Makefile.am

@@ -4,7 +4,7 @@ noinst_LTLIBRARIES = libtaocrypt.la
 
 libtaocrypt_la_SOURCES  = aes.cpp aestables.cpp algebra.cpp arc4.cpp \
         asn.cpp bftables.cpp blowfish.cpp coding.cpp des.cpp dh.cpp \
-        dsa.cpp file.cpp hash.cpp integer.cpp md2.cpp md5.cpp misc.cpp \
+        dsa.cpp file.cpp hash.cpp integer.cpp md2.cpp md4.cpp md5.cpp misc.cpp \
         random.cpp ripemd.cpp rsa.cpp sha.cpp template_instnt.cpp \
         tftables.cpp twofish.cpp
 

extra/yassl/taocrypt/src/md4.cpp

+/* md4.cpp                                
+ *
+ * Copyright (C) 2003 Sawtooth Consulting Ltd.
+ *
+ * This file is part of yaSSL.
+ *
+ * yaSSL is free software; you can redistribute it and/or modify
+ * 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.
+ *
+ * yaSSL 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
+ */
+
+
+/* based on Wei Dai's md4.cpp from CryptoPP */
+
+#include "runtime.hpp"
+#include "md4.hpp"
+#include "algorithm.hpp"    // mySTL::swap
+
+   
+
+namespace TaoCrypt {
+
+void MD4::Init()
+{
+    digest_[0] = 0x67452301L;
+    digest_[1] = 0xefcdab89L;
+    digest_[2] = 0x98badcfeL;
+    digest_[3] = 0x10325476L;
+
+    buffLen_ = 0;
+    loLen_  = 0;
+    hiLen_  = 0;
+}
+
+
+MD4::MD4(const MD4& that) : HASHwithTransform(DIGEST_SIZE / sizeof(word32),
+                                              BLOCK_SIZE) 
+{ 
+    buffLen_ = that.buffLen_;
+    loLen_  =  that.loLen_;
+    hiLen_  =  that.hiLen_;
+
+    memcpy(digest_, that.digest_, DIGEST_SIZE);
+    memcpy(buffer_, that.buffer_, BLOCK_SIZE);
+}
+
+MD4& MD4::operator= (const MD4& that)
+{
+    MD4 tmp(that);
+    Swap(tmp);
+
+    return *this;
+}
+
+
+void MD4::Swap(MD4& other)
+{
+    mySTL::swap(loLen_,   other.loLen_);
+    mySTL::swap(hiLen_,   other.hiLen_);
+    mySTL::swap(buffLen_, other.buffLen_);
+
+    memcpy(digest_, other.digest_, DIGEST_SIZE);
+    memcpy(buffer_, other.buffer_, BLOCK_SIZE);
+}
+
+
+void MD4::Transform()
+{
+#define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
+#define G(x, y, z) (((x) & (y)) | ((x) & (z)) | ((y) & (z)))
+#define H(x, y, z) ((x) ^ (y) ^ (z))
+
+    word32 A, B, C, D;
+
+    A = digest_[0];
+    B = digest_[1];
+    C = digest_[2];
+    D = digest_[3];
+
+#define function(a,b,c,d,k,s) a=rotlFixed(a+F(b,c,d)+buffer_[k],s);
+    function(A,B,C,D, 0, 3);
+    function(D,A,B,C, 1, 7);
+    function(C,D,A,B, 2,11);
+    function(B,C,D,A, 3,19);
+    function(A,B,C,D, 4, 3);
+    function(D,A,B,C, 5, 7);
+    function(C,D,A,B, 6,11);
+    function(B,C,D,A, 7,19);
+    function(A,B,C,D, 8, 3);
+    function(D,A,B,C, 9, 7);
+    function(C,D,A,B,10,11);
+    function(B,C,D,A,11,19);
+    function(A,B,C,D,12, 3);
+    function(D,A,B,C,13, 7);
+    function(C,D,A,B,14,11);
+    function(B,C,D,A,15,19);
+
+#undef function	  
+#define function(a,b,c,d,k,s) a=rotlFixed(a+G(b,c,d)+buffer_[k]+0x5a827999,s);
+    function(A,B,C,D, 0, 3);
+    function(D,A,B,C, 4, 5);
+    function(C,D,A,B, 8, 9);
+    function(B,C,D,A,12,13);
+    function(A,B,C,D, 1, 3);
+    function(D,A,B,C, 5, 5);
+    function(C,D,A,B, 9, 9);
+    function(B,C,D,A,13,13);
+    function(A,B,C,D, 2, 3);
+    function(D,A,B,C, 6, 5);
+    function(C,D,A,B,10, 9);
+    function(B,C,D,A,14,13);
+    function(A,B,C,D, 3, 3);
+    function(D,A,B,C, 7, 5);
+    function(C,D,A,B,11, 9);
+    function(B,C,D,A,15,13);
+
+#undef function	 
+#define function(a,b,c,d,k,s) a=rotlFixed(a+H(b,c,d)+buffer_[k]+0x6ed9eba1,s);
+    function(A,B,C,D, 0, 3);
+    function(D,A,B,C, 8, 9);
+    function(C,D,A,B, 4,11);
+    function(B,C,D,A,12,15);
+    function(A,B,C,D, 2, 3);
+    function(D,A,B,C,10, 9);
+    function(C,D,A,B, 6,11);
+    function(B,C,D,A,14,15);
+    function(A,B,C,D, 1, 3);
+    function(D,A,B,C, 9, 9);
+    function(C,D,A,B, 5,11);
+    function(B,C,D,A,13,15);
+    function(A,B,C,D, 3, 3);
+    function(D,A,B,C,11, 9);
+    function(C,D,A,B, 7,11);
+    function(B,C,D,A,15,15);
+
+    digest_[0] += A;
+    digest_[1] += B;
+    digest_[2] += C;
+    digest_[3] += D;
+}
+
+
+} // namespace
+