コード例 #1
0
        private void GetConnectNumber(int timeOut)
        {
            AutoResetEvent autoResetEvent = new AutoResetEvent(false);
            IntPtr         handle         = SharedMemoryStream.OpenEvent(1048578u, false, this.memoryName + "_CONNECT_REQUEST");

            autoResetEvent.Handle = (handle);
            AutoResetEvent autoResetEvent2 = new AutoResetEvent(false);

            handle = SharedMemoryStream.OpenEvent(1048578u, false, this.memoryName + "_CONNECT_ANSWER");
            autoResetEvent2.Handle = (handle);
            IntPtr hFileMappingObject = SharedMemoryStream.OpenFileMapping(2u, false, this.memoryName + "_CONNECT_DATA");
            IntPtr intPtr             = SharedMemoryStream.MapViewOfFile(hFileMappingObject, 2u, 0u, 0u, (IntPtr)4);

            if (!autoResetEvent.Set())
            {
                throw new MySqlException("Failed to open shared memory connection ");
            }
            autoResetEvent2.WaitOne(timeOut * 1000, false);
            this.connectNumber = Marshal.ReadInt32(intPtr);
        }
コード例 #2
0
        private void SetupEvents()
        {
            string text = this.memoryName + "_" + this.connectNumber;

            this.dataMap     = SharedMemoryStream.OpenFileMapping(2u, false, text + "_DATA");
            this.dataView    = SharedMemoryStream.MapViewOfFile(this.dataMap, 2u, 0u, 0u, (IntPtr)16004);
            this.serverWrote = new AutoResetEvent(false);
            IntPtr handle = SharedMemoryStream.OpenEvent(1048578u, false, text + "_SERVER_WROTE");

            this.serverWrote.Handle = handle;
            this.serverRead         = new AutoResetEvent(false);
            handle = SharedMemoryStream.OpenEvent(1048578u, false, text + "_SERVER_READ");
            this.serverRead.Handle = handle;
            this.clientWrote       = new AutoResetEvent(false);
            handle = SharedMemoryStream.OpenEvent(1048578u, false, text + "_CLIENT_WROTE");
            this.clientWrote.Handle = handle;
            this.clientRead         = new AutoResetEvent(false);
            handle = SharedMemoryStream.OpenEvent(1048578u, false, text + "_CLIENT_READ");
            this.clientRead.Handle = handle;
            this.serverRead.Set();
        }
コード例 #3
0
        public bool IsClosed()
        {
            bool result;

            try
            {
                this.dataView = SharedMemoryStream.MapViewOfFile(this.dataMap, 2u, 0u, 0u, (IntPtr)16004);
                if (this.dataView == IntPtr.Zero)
                {
                    result = true;
                }
                else
                {
                    result = false;
                }
            }
            catch (Exception)
            {
                result = true;
            }
            return(result);
        }
コード例 #4
0
        public override void Open()
        {
            base.Open();

            // connect to one of our specified hosts
            Stream stream;

            try
            {
                if (Settings.Protocol == ConnectionProtocol.SharedMemory)
                {
                    SharedMemoryStream str = new SharedMemoryStream(Settings.SharedMemoryName);
                    str.Open(Settings.ConnectionTimeout);
                    stream = str;
                }
                else
                {
                    string pipeName = Settings.PipeName;
                    if (Settings.Protocol != ConnectionProtocol.NamedPipe)
                    {
                        pipeName = null;
                    }
                    StreamCreator sc = new StreamCreator(Settings.Server, Settings.Port, pipeName);
                    stream = sc.GetStream(Settings.ConnectionTimeout);
                }
            }
            catch (Exception ex)
            {
                throw new MySqlException("Unable to connect to any of the specified MySQL hosts", ex);
            }


            if (stream == null)
            {
                throw new MySqlException("Unable to connect to any of the specified MySQL hosts");
            }

            reader          = new PacketReader(new BufferedStream(stream), this);
            writer          = new PacketWriter(new BufferedStream(stream), this);
            writer.Encoding = encoding;

            // read off the welcome packet and parse out it's values
            reader.OpenPacket();
            protocol = reader.ReadByte();
            string versionString = reader.ReadString();

            version        = DBVersion.Parse(versionString);
            threadId       = (int)reader.ReadInteger(4);
            encryptionSeed = reader.ReadString();

            // starting with 4.0.8, maxSinglePacket should be 0xffffff
            if (version.isAtLeast(4, 0, 8))
            {
                MaxSinglePacket = (256 * 256 * 256) - 1;
            }

            // read in Server capabilities if they are provided
            serverCaps = 0;
            if (reader.HasMoreData)
            {
                serverCaps = (ClientFlags)reader.ReadInteger(2);
            }

            // based on our settings, set our connection flags
            SetConnectionFlags();

            writer.StartPacket(0);
            writer.WriteInteger((int)connectionFlags, version.isAtLeast(4, 1, 0) ? 4 : 2);
            writer.WriteInteger(MaxSinglePacket, version.isAtLeast(4, 1, 0) ? 4 : 3);

            // 4.1.1 included some new server status info
            if (version.isAtLeast(4, 1, 1))
            {
                /* New protocol with 16 bytes to describe server characteristics */
                serverLanguage = reader.ReadInteger(1);
                serverStatus   = (ServerStatusFlags)reader.ReadInteger(2);
                reader.Skip(13);

                string seedPart2 = reader.ReadString();
                encryptionSeed += seedPart2;

                writer.WriteByte(8);
                writer.Write(new byte[23], 0, 23);
            }

            Authenticate();

            // if we are using compression, then we use our CompressedStream class
            // to hide the ugliness of managing the compression
            if ((connectionFlags & ClientFlags.COMPRESS) != 0)
            {
                //stream = new CompressedStream( stream, MaxSinglePacket );
                writer          = new PacketWriter(new CompressedStream(new BufferedStream(stream)), this);
                writer.Encoding = encoding;
                reader          = new PacketReader(new CompressedStream(new BufferedStream(stream)), this);
            }

            isOpen = true;
        }
コード例 #5
0
ファイル: NativeDriver.cs プロジェクト: zwdgithub/NovelGetter
        public override void Open()
        {
            base.Open();
            Stream stream;

            try
            {
                if (base.Settings.Protocol == ConnectionProtocol.SharedMemory)
                {
                    SharedMemoryStream sharedMemoryStream = new SharedMemoryStream(base.Settings.SharedMemoryName);
                    sharedMemoryStream.Open(base.Settings.ConnectionTimeout);
                    stream = sharedMemoryStream;
                }
                else
                {
                    string pipeName = base.Settings.PipeName;
                    if (base.Settings.Protocol != ConnectionProtocol.NamedPipe)
                    {
                        pipeName = null;
                    }
                    StreamCreator streamCreator = new StreamCreator(base.Settings.Server, base.Settings.Port, pipeName);
                    stream = streamCreator.GetStream((uint)base.Settings.ConnectionTimeout);
                }
                if (stream == null)
                {
                    throw new Exception();
                }
            }
            catch (Exception inner)
            {
                throw new MySqlException(Resources.UnableToConnectToHost, 1042, inner);
            }
            if (stream == null)
            {
                throw new MySqlException("Unable to connect to any of the specified MySQL hosts");
            }
            this.reader          = new PacketReader(new BufferedStream(stream), this);
            this.writer          = new PacketWriter(new BufferedStream(stream), this);
            this.writer.Encoding = this.encoding;
            this.reader.OpenPacket();
            this.protocol = this.reader.ReadByte();
            string versionString = this.reader.ReadString();

            this.version        = DBVersion.Parse(versionString);
            this.threadId       = this.reader.ReadInteger(4);
            this.encryptionSeed = this.reader.ReadString();
            if (this.version.isAtLeast(4, 0, 8))
            {
                this.MaxSinglePacket = 16777215;
            }
            this.serverCaps = (ClientFlags)0;
            if (this.reader.HasMoreData)
            {
                this.serverCaps = (ClientFlags)this.reader.ReadInteger(2);
            }
            this.SetConnectionFlags();
            this.writer.StartPacket(0L);
            this.writer.WriteInteger((long)this.connectionFlags, this.version.isAtLeast(4, 1, 0) ? 4 : 2);
            this.writer.WriteInteger((long)this.MaxSinglePacket, this.version.isAtLeast(4, 1, 0) ? 4 : 3);
            if (this.version.isAtLeast(4, 1, 1))
            {
                this.serverLanguage = this.reader.ReadInteger(1);
                this.serverStatus   = (ServerStatusFlags)this.reader.ReadInteger(2);
                this.reader.Skip(13L);
                string text = this.reader.ReadString();
                this.encryptionSeed += text;
                this.writer.WriteByte(8);
                this.writer.Write(new byte[23], 0, 23);
            }
            this.Authenticate();
            if ((this.connectionFlags & ClientFlags.COMPRESS) != (ClientFlags)0)
            {
                this.writer          = new PacketWriter(new BufferedStream(new CompressedStream(stream)), this);
                this.writer.Encoding = this.encoding;
                this.reader          = new PacketReader(new BufferedStream(new CompressedStream(stream)), this);
            }
            this.isOpen = true;
        }
コード例 #6
0
        public void Open()
        {
            // connect to one of our specified hosts
            try
            {
#if !CF
                if (Settings.ConnectionProtocol == MySqlConnectionProtocol.SharedMemory)
                {
                    SharedMemoryStream str = new SharedMemoryStream(Settings.SharedMemoryName);
                    str.Open(Settings.ConnectionTimeout);
                    baseStream = str;
                }
                else
                {
#endif
                string pipeName = Settings.PipeName;
                if (Settings.ConnectionProtocol != MySqlConnectionProtocol.NamedPipe)
                {
                    pipeName = null;
                }
                StreamCreator sc = new StreamCreator(Settings.Server, Settings.Port, pipeName,
                                                     Settings.Keepalive, this.Version);
#if !CF
                MySqlSecurityPermission.CreatePermissionSet(false).Assert();
#endif
                baseStream = sc.GetStream(Settings.ConnectionTimeout);
#if !CF
            }
#endif
            }
            catch (System.Security.SecurityException)
            {
                throw;
            }
            catch (Exception ex)
            {
                throw new MySqlException(Resources.UnableToConnectToHost,
                                         (int)MySqlErrorCode.UnableToConnectToHost, ex);
            }
            if (baseStream == null)
            {
                throw new MySqlException(Resources.UnableToConnectToHost,
                                         (int)MySqlErrorCode.UnableToConnectToHost);
            }

            int maxSinglePacket = 255 * 255 * 255;
            stream = new MySqlStream(baseStream, Encoding, false);

            stream.ResetTimeout((int)Settings.ConnectionTimeout * 1000);

            // read off the welcome packet and parse out it's values
            packet = stream.ReadPacket();
            int protocol         = packet.ReadByte();
            string versionString = packet.ReadString();
            version = DBVersion.Parse(versionString);
            if (!version.isAtLeast(5, 0, 0))
            {
                throw new NotSupportedException(Resources.ServerTooOld);
            }
            threadId       = packet.ReadInteger(4);
            encryptionSeed = packet.ReadString();

            maxSinglePacket = (256 * 256 * 256) - 1;

            // read in Server capabilities if they are provided
            ClientFlags serverCaps = 0;
            if (packet.HasMoreData)
            {
                serverCaps = (ClientFlags)packet.ReadInteger(2);
            }

            /* New protocol with 16 bytes to describe server characteristics */
            owner.ConnectionCharSetIndex = (int)packet.ReadByte();

            serverStatus = (ServerStatusFlags)packet.ReadInteger(2);

            // Since 5.5, high bits of server caps are stored after status.
            // Previously, it was part of reserved always 0x00 13-byte filler.
            uint serverCapsHigh = (uint)packet.ReadInteger(2);
            serverCaps |= (ClientFlags)(serverCapsHigh << 16);

            packet.Position += 11;
            string seedPart2 = packet.ReadString();
            encryptionSeed += seedPart2;

            string authenticationMethod = "";
            if ((serverCaps & ClientFlags.PLUGIN_AUTH) != 0)
            {
                authenticationMethod = packet.ReadString();
            }

            // based on our settings, set our connection flags
            SetConnectionFlags(serverCaps);

            packet.Clear();
            packet.WriteInteger((int)connectionFlags, 4);

#if !CF
            if ((serverCaps & ClientFlags.SSL) == 0)
            {
                if ((Settings.SslMode != MySqlSslMode.None) &&
                    (Settings.SslMode != MySqlSslMode.Preferred))
                {
                    // Client requires SSL connections.
                    string message = String.Format(Resources.NoServerSSLSupport,
                                                   Settings.Server);
                    throw new MySqlException(message);
                }
            }
            else if (Settings.SslMode != MySqlSslMode.None)
            {
                stream.SendPacket(packet);
                StartSSL();
                packet.Clear();
                packet.WriteInteger((int)connectionFlags, 4);
            }
#endif

            packet.WriteInteger(maxSinglePacket, 4);
            packet.WriteByte(8);
            packet.Write(new byte[23]);

            Authenticate(false);

            // if we are using compression, then we use our CompressedStream class
            // to hide the ugliness of managing the compression
            if ((connectionFlags & ClientFlags.COMPRESS) != 0)
            {
                stream = new MySqlStream(baseStream, Encoding, true);
            }

            // give our stream the server version we are connected to.
            // We may have some fields that are read differently based
            // on the version of the server we are connected to.
            packet.Version      = version;
            stream.MaxBlockSize = maxSinglePacket;
        }
コード例 #7
0
        public override void Open()
        {
            base.Open();

            // connect to one of our specified hosts
            try
            {
#if !CF
                if (Settings.ConnectionProtocol == MySqlConnectionProtocol.SharedMemory)
                {
                    SharedMemoryStream str = new SharedMemoryStream(Settings.SharedMemoryName);
                    str.Open(Settings.ConnectionTimeout);
                    baseStream = str;
                }
                else
                {
#endif
                string pipeName = Settings.PipeName;
                if (Settings.ConnectionProtocol != MySqlConnectionProtocol.NamedPipe)
                {
                    pipeName = null;
                }
                StreamCreator sc = new StreamCreator(Settings.Server, Settings.Port, pipeName);
                baseStream = sc.GetStream(Settings.ConnectionTimeout);
#if !CF
            }
#endif
                if (baseStream == null)
                {
                    throw new Exception();
                }
            }
            catch (Exception ex)
            {
                throw new MySqlException(Resources.UnableToConnectToHost,
                                         (int)MySqlErrorCode.UnableToConnectToHost, ex);
            }

            if (baseStream == null)
            {
                throw new MySqlException("Unable to connect to any of the specified MySQL hosts");
            }

            int maxSinglePacket = 255 * 255 * 255;
            stream = new MySqlStream(baseStream, encoding, false);

            // read off the welcome packet and parse out it's values
            stream.OpenPacket();
            protocol = stream.ReadByte();
            string versionString = stream.ReadString();
            version        = DBVersion.Parse(versionString);
            threadId       = stream.ReadInteger(4);
            encryptionSeed = stream.ReadString();

            if (version.isAtLeast(4, 0, 8))
            {
                maxSinglePacket = (256 * 256 * 256) - 1;
            }

            // read in Server capabilities if they are provided
            serverCaps = 0;
            if (stream.HasMoreData)
            {
                serverCaps = (ClientFlags)stream.ReadInteger(2);
            }
            if (version.isAtLeast(4, 1, 1))
            {
                /* New protocol with 16 bytes to describe server characteristics */
                serverCharSetIndex = stream.ReadInteger(1);

                serverStatus = (ServerStatusFlags)stream.ReadInteger(2);
                stream.SkipBytes(13);
                string seedPart2 = stream.ReadString();
                encryptionSeed += seedPart2;
            }

            // based on our settings, set our connection flags
            SetConnectionFlags();

            stream.StartOutput(0, false);
            stream.WriteInteger((int)connectionFlags,
                                version.isAtLeast(4, 1, 0) ? 4 : 2);

#if !CF
            if (connectionString.UseSSL && (serverCaps & ClientFlags.SSL) != 0)
            {
                stream.Flush();

                StartSSL();

                stream.StartOutput(0, false);
                stream.WriteInteger((int)connectionFlags,
                                    version.isAtLeast(4, 1, 0) ? 4 : 2);
            }
#endif

            stream.WriteInteger(maxSinglePacket,
                                version.isAtLeast(4, 1, 0) ? 4 : 3);

            if (version.isAtLeast(4, 1, 1))
            {
                stream.WriteByte(8);
                stream.Write(new byte[23]);
            }

            Authenticate();

            // if we are using compression, then we use our CompressedStream class
            // to hide the ugliness of managing the compression
            if ((connectionFlags & ClientFlags.COMPRESS) != 0)
            {
                stream = new MySqlStream(baseStream, encoding, true);
            }

            // give our stream the server version we are connected to.
            // We may have some fields that are read differently based
            // on the version of the server we are connected to.
            stream.Version      = version;
            stream.MaxBlockSize = maxSinglePacket;

            isOpen = true;
        }
コード例 #8
0
 public override void Close()
 {
     SharedMemoryStream.UnmapViewOfFile(this.dataView);
     SharedMemoryStream.CloseHandle(this.dataMap);
 }
コード例 #9
0
 public override void Flush()
 {
     SharedMemoryStream.FlushViewOfFile(this.dataView, 0u);
 }