Пример #1
0
		public static FileSystemRecord Get(Stream volume, byte[] buffer1, byte[] buffer2, int sector)
		{
			DirectoryRecord directory;
			FileRecord file;

			long pos = (long)sector * 512L;
			volume.Position = pos;
			volume.Read(buffer1, 0, 512);
			if (BitConverter.ToUInt32(buffer1, 4) != 1179208773)
			{ 
				directory = new DirectoryRecord();
				directory.Name = sector.ToString();
				Console.WriteLine("Not a FILE record, " + sector + "!"); 
				return directory;
			}

			pos = (long)BitConverter.ToInt32(buffer1, 8) * 512L;
			volume.Position = pos;
			volume.Read(buffer2, 0, 512);

			switch (BitConverter.ToUInt32(buffer2, 4))
			{
				case 1179208773: // child is a FILE, it's a dir!
					directory = new DirectoryRecord();
					FillFileSystemRecord(volume, buffer1, directory);
					int next = directory.Child;
					while (next != 0)
					{
						directory.Children.Add(next);
						volume.Position = (long)next * 512L;
						volume.Read(buffer1, 0, 512);
						next = BitConverter.ToInt32(buffer1, 60);
					}
					return directory;
				case 1414677829: // child is a TREE, it's a dir again!
					directory = new DirectoryRecord();
					FillFileSystemRecord(volume, buffer1, directory);
					FillTree(volume, buffer2, directory.Child, sector, directory.Children);
					return directory;
				case 1095520067: // child is an ALOC, it's a file!
					file = new FileRecord();
					FillFileSystemRecord(volume, buffer1, file);
					file.Allocation = ByteKiller(buffer2, 8, 496);
					file.AllocationStart = file.Child + file.Allocation[1];
					file.Allocation[1] = 0;
					file.UnusedBytes = BitConverter.ToInt32(buffer2, 504);
					file.SectorCount = BitConverter.ToInt32(buffer2, 508);
					if (file.SectorCount * 512 - file.UnusedBytes != file.Size) Console.WriteLine("File " + sector + " isn't correct size!");
					return file;
				default: // usually empty file
					file = new FileRecord();
					FillFileSystemRecord(volume, buffer1, file);
					file.Allocation = new int[0];
					file.AllocationStart = 0;
					file.UnusedBytes = 0;
					file.SectorCount = 0;
					if (file.Child != 0) Console.WriteLine("Uh, I dunno what's the problem, " + sector + ".");
					return file;
			}
		}
Пример #2
0
        public static void TransformFile(byte[] key, byte[] iv, Stream dstfs, Stream srcfs, long offset, long length)
        {
            var aes = new Aes128Ctr(key, iv);
            var counter = BitConverter.ToUInt64(aes._iv.Reverse().ToArray(), 0); //get the nonce

            byte[] buffer;
            long buffersize = 1024 * 1024 * 4;
            while (offset > 0)
            {
                buffersize = offset > buffersize ? buffersize : offset;
                buffer = new byte[buffersize];
                srcfs.Read(buffer, 0, (int)buffersize);
                counter = aes.TransformBlock(buffer, counter);
                offset -= buffersize;
            }
            buffersize = 1024 * 1024 * 4;
            while (length > 0)
            {
                buffersize = length > buffersize ? buffersize : length;
                buffer = new byte[buffersize];
                srcfs.Read(buffer, 0, (int)buffersize);
                counter = aes.TransformBlock(buffer, counter);
                dstfs.Write(buffer, 0, (int)buffersize);
                length -= buffersize;
            }
        }
        public static bool TryRead(Stream stream, out LengthedPrefixedString s)
        {
            s = null;
            if (!MatchHeader(stream))
                return false;

            var lengthBytes = new byte[4];
            if (stream.Read(lengthBytes, 0, 4) < 4)
                return false;

            int length = BitConverter.ToInt32(lengthBytes, 0);
            var stringBytes = new byte[length];

            if (stream.Read(stringBytes, 0, length) < length)
                return false;
            try
            {
                string data = Encoding.UTF8.GetString(stringBytes);
                s = new LengthedPrefixedString(data);
            }
            catch
            {
                return false;
            }

            if (!HasTerminator(stream))
                return false;

            return true;
        }
Пример #4
0
        // Source: http://blogs.msdn.com/b/feroze_daud/archive/2004/03/30/104440.aspx
        public static String Decode(WebResponse response, Stream stream)
        {
            String charset = null;
            String contentType = response.Headers["content-type"];
            if(contentType != null)
            {
                int index = contentType.IndexOf("charset=");
                if(index != -1)
                {
                    charset = contentType.Substring(index + 8);
                }
            }

            MemoryStream data = new MemoryStream();
            byte[] buffer = new byte[1024];
            int read = stream.Read(buffer, 0, buffer.Length);
            while(read > 0)
            {
                data.Write(buffer, 0, read);
                read = stream.Read(buffer, 0, buffer.Length);
            }
            stream.Close();

            Encoding encoding = Encoding.UTF8;
            try
            {
                if(charset != null)
                    encoding = Encoding.GetEncoding(charset);
            }
            catch { }

            data.Seek(0, SeekOrigin.Begin);
            StreamReader streamReader = new StreamReader(data, encoding);
            return streamReader.ReadToEnd();
        }
Пример #5
0
		/// <summary>
		/// Returns the CRC32 for the specified stream, and writes the input into the output stream.
		/// </summary>
		/// <param name="input">The stream over which to calculate the CRC32</param>
		/// <param name="output">The stream into which to deflate the input</param>
		/// <returns>the CRC32 calculation</returns>
		public UInt32 GetCrc32AndCopy(Stream input, Stream output)
		{
			unchecked
			{
				UInt32 crc32Result;
				crc32Result = 0xFFFFFFFF;
				byte[] buffer = new byte[BufferSize];
				int readSize = BufferSize;

				m_TotalBytesRead = 0;
				int count = input.Read(buffer, 0, readSize);
				if (output != null) output.Write(buffer, 0, count);
				m_TotalBytesRead += count;
				while (count > 0)
				{
					for (int i = 0; i < count; i++)
					{
						crc32Result = ((crc32Result) >> 8) ^ m_crc32Table[(buffer[i]) ^ ((crc32Result) & 0x000000FF)];
					}
					count = input.Read(buffer, 0, readSize);
					if (output != null) output.Write(buffer, 0, count);
					m_TotalBytesRead += count;

				}

				return ~crc32Result;
			}
		}
Пример #6
0
        internal static Bitmap Parse(Stream stream, bool ignoreAlpha = false)
        {
            Bitmap Result = null;

            var Flag = stream.Read<byte>(0x30);
            var Header = stream.Read<ImageHeader>(0x41);

            using (BinaryReader Reader = new BinaryReader(stream))
            {
                switch (Header.Type)
                {
                case ImageType.DXT1:
                case ImageType.DXT2:
                case ImageType.DXT3:
                case ImageType.DXT4:
                case ImageType.DXT5:
                    // Unknown 8 bytes
                    Reader.ReadBytes(8);

                    Result = DxtParser.Parse(Reader, Header, ignoreAlpha);
                    break;
                case ImageType.Bitmap:
                    Result = BitmapParser.Parse(Reader, Header, ignoreAlpha);
                    break;
                default:
                    throw new InvalidDataException(string.Format(CultureInfo.InvariantCulture, "Image type {0} not supported: {1}", Header.Type, Flag));
                }
            }

            return Result;
        }
Пример #7
0
        public Texture2D Read(Stream inputStream, GraphicsDevice graphicsDevice)
        {
            if (IsPngImage(inputStream) == false)
            {
                throw new Exception("File does not have PNG signature.");
            }

            inputStream.Position = 8;

            while (inputStream.Position != inputStream.Length)
            {
                byte[] chunkDataLengthBytes = new byte[4];
                inputStream.Read(chunkDataLengthBytes, 0, 4);
                uint chunkDataLength = chunkDataLengthBytes.ToUInt();

                inputStream.Position -= 4;

                byte[] chunkBytes = new byte[12 + chunkDataLength];
                inputStream.Read(chunkBytes, 0, (int)(12 + chunkDataLength));

                ProcessChunk(chunkBytes);
            }

            UnpackDataChunks();

            texture = new Texture2D(graphicsDevice, width, height, false, SurfaceFormat.Color);
            texture.SetData<Color>(data);

            return texture;
        }
Пример #8
0
        public override object Deserialize(Stream stream)
        {
            if (encryptionEnabled)
            {
                string descriptorName = stream.ReadUTF();
                int length = stream.ReadInt();
                byte[] buffer = stream.Read(length);

                string privateKey = serverAuthority.GenerateAgreementValue(remotePublicKey).ToString(16);
                RijndaelCrypto crypto = new RijndaelCrypto();

                Type t = registry.GetTypeForDescriptor(crypto.Decrypt(descriptorName, privateKey));
                if (t != null)
                {
                    return ReflectionHelper.InvokeStaticMethodOnType(t, "ParseFrom", crypto.Decrypt(buffer, privateKey));
                }

            }
            else
            {
                string descriptorName = stream.ReadUTF();

                int length = stream.ReadInt();
                byte[] buffer = stream.Read(length);

                Type t = registry.GetTypeForDescriptor(descriptorName);
                if (t != null)
                {
                    return ReflectionHelper.InvokeStaticMethodOnType(t, "ParseFrom", buffer);
                }
            }

            return null;
        }
Пример #9
0
        /// <summary>Reads a new WAVE format section from the specified stream.</summary>
        /// <param name="preRead">Pre-parsed RIFF chunk header.</param>
        /// <param name="source">Source stream to read data from.</param>
        /// <param name="waveFormat">Format of the data section to be parsed.</param>
        /// <exception cref="InvalidOperationException">WAVE format or extra parameters section too small, wave file corrupted.</exception>
        public WaveDataChunk(RiffChunk preRead, Stream source, WaveFormatChunk waveFormat)
            : base(preRead, RiffTypeID)
        {
            m_waveFormat = waveFormat;
            m_sampleBlocks = new List<LittleBinaryValue[]>();

            int blockSize = waveFormat.BlockAlignment;
            int sampleSize = waveFormat.BitsPerSample / 8;
            byte[] buffer = new byte[blockSize];
            int channels = waveFormat.Channels;
            LittleBinaryValue[] sampleBlock;

            int bytesRead = source.Read(buffer, 0, blockSize);

            while (bytesRead == blockSize)
            {
                // Create a new sample block, one binary sample value for each channel
                sampleBlock = new LittleBinaryValue[channels];

                for (int x = 0; x < channels; x++)
                {
                    sampleBlock[x] = new LittleBinaryValue(buffer.CopyBuffer(x * sampleSize, sampleSize));
                }

                m_sampleBlocks.Add(sampleBlock);

                bytesRead = source.Read(buffer, 0, blockSize);
            }
        }
Пример #10
0
        static void CopyLength(Stream fs, string dstFilePath, long fileLength, IEnumerable<byte> expectedHash)
        {
            const int bufSz = 65536;
            var remain = fileLength;
            var buffer = new byte[bufSz];
            using (var md5 = MD5.Create())
            using (var fout = NativeIO.OpenFileStream(new PathInfo(dstFilePath), FileAccess.Write, FileMode.CreateNew))
            {
                int len;
                while (remain > bufSz)
                {
                    len = fs.Read(buffer, 0, bufSz);
                    if (len != bufSz) throw new Exception("Malformed file: data truncated");
                    md5.TransformBlock(buffer, 0, len, null, 0);
                    fout.Write(buffer, 0, bufSz);
                    remain -= bufSz;
                }

                if (remain != 0)
                {
                    len = fs.Read(buffer, 0, (int)remain);
                    if (len != remain) throw new Exception("Malformed file: data truncated at end");
                    md5.TransformBlock(buffer, 0, (int)remain, null, 0);
                    fout.Write(buffer, 0, (int)remain);
                }

                md5.TransformFinalBlock(new byte[0], 0, 0);
                if (!HashesEqual(expectedHash, md5.Hash)) { throw new Exception("Damaged archive: File at " + dstFilePath + " failed a checksum"); }
            }
        }
Пример #11
0
        public bool UploadChunk(Stream stream)
        {
            int bufferSize = 1024 * 1024 * 8;
            byte[] guidBuffer = new byte[16];
            byte[] readBuffer = new byte[bufferSize];

            int count = 0;
            int pos = 0;
            while (pos < 16)
                pos += stream.Read(guidBuffer, pos, 16 - pos);
            Guid guid = new Guid(guidBuffer);

            string filePath = Path.Combine(
                Properties.Settings.Default.WorkingFolder,
                String.Format(".\\{0}.chunk",guid.ToString()));

            using(FileStream writer = new FileStream(filePath,FileMode.Create))
            {
                while((count = stream.Read(readBuffer, 0, bufferSize)) > 0)
                {
                    writer.Write(readBuffer,0,count);
                }
            }
            stream.Close();

            return true;
        }
Пример #12
0
 /// <summary>
 /// Reads and inserts all key value pairs into current prefix from stream
 /// </summary>
 /// <param name="transaction">transaction where to import all data</param>
 /// <param name="stream">where to read it from</param>
 public static void Import(IKeyValueDBTransaction transaction, Stream stream)
 {
     if (transaction == null) throw new ArgumentNullException(nameof(transaction));
     if (stream == null) throw new ArgumentNullException(nameof(stream));
     if (!stream.CanRead) throw new ArgumentException("stream must be readable", nameof(stream));
     var tempbuf = new byte[4096];
     var tempbuf2 = new byte[4096];
     if (stream.Read(tempbuf, 0, 16) != 16) throw new EndOfStreamException();
     if (tempbuf[0] != 'B' || tempbuf[1] != 'T' || tempbuf[2] != 'D' || tempbuf[3] != 'B' || tempbuf[4] != 'E' || tempbuf[5] != 'X' || tempbuf[6] != 'P' || tempbuf[7] != '2')
     {
         throw new BTDBException("Invalid header (it should Start with BTDBEXP2)");
     }
     var keyValuePairs = PackUnpack.UnpackInt64LE(tempbuf, 8);
     if (keyValuePairs < 0) throw new BTDBException("Negative number of key value pairs");
     for (var kv = 0; kv < keyValuePairs; kv++)
     {
         if (stream.Read(tempbuf, 0, 4) != 4) throw new EndOfStreamException();
         var keySize = PackUnpack.UnpackInt32LE(tempbuf, 0);
         if (keySize < 0) throw new BTDBException("Negative key size");
         if (keySize > tempbuf.Length) tempbuf = new byte[keySize];
         if (stream.Read(tempbuf, 0, keySize) != keySize) throw new EndOfStreamException();
         if (stream.Read(tempbuf2, 0, 4) != 4) throw new EndOfStreamException();
         var valueSize = PackUnpack.UnpackInt32LE(tempbuf2, 0);
         if (valueSize < 0) throw new BTDBException("Negative value size");
         if (valueSize > tempbuf2.Length) tempbuf2 = new byte[valueSize]; 
         if (stream.Read(tempbuf2, 0, valueSize) != valueSize) throw new EndOfStreamException();
         transaction.CreateOrUpdateKeyValue(ByteBuffer.NewSync(tempbuf,0,keySize),ByteBuffer.NewSync(tempbuf2,0,valueSize));
     }
 }
Пример #13
0
        private void CreateV1Frames(Stream stream)
        {
            // ID1 header am ende ...
            stream.Seek(-125, SeekOrigin.End);
            // 30 zeichen title     => TIT2
            // 30 zeichen artist    => TCOM
            // 30 zeichen album     => TALB
            // 4 zeichen jahr       => TYER
            // 30 zeichen commentar - kann auch den track enthalten (TRCK) - der letzte byte
            // 1 byte Genre
            // == 125

            foreach (var item in new[] { "TIT2", "TCOM", "TALB" })
            {
                AddFrame(item, ByteHelper.BytesToString(stream.Read(30)));
            }
            AddFrame("TYER", ByteHelper.BytesToString(stream.Read(4)));

            // comment - egal
            stream.Seek(28, SeekOrigin.Current);
            var track = stream.Read(2);
            if (track[0] == 0 && track[1] != 0)
            {
                // dann ist track[1] eine zahl;
                if (track[1] < 48)
                {
                    AddFrame("TRCK",((int)track[1]).ToString());
                }
            }
        }
Пример #14
0
        public static long CheckKeyForMessage(Stream keyStream, long messageLength)
        {
            long messageLengthBits = messageLength * 8;
            long countRequiredSamples = 0;

            if (messageLengthBits > keyStream.Length)
            {
                long keyLength = keyStream.Length;

                byte[] keyBytes = new byte[keyLength];
                keyStream.Read(keyBytes, 0, keyBytes.Length);

                countRequiredSamples = SumKeyArray(keyBytes);

                double countKeyCopies = messageLengthBits / keyLength;

                countRequiredSamples = (long)(countRequiredSamples * countKeyCopies);

            }
            else
            {
                byte[] keyBytes = new byte[messageLengthBits];
                keyStream.Read(keyBytes, 0, keyBytes.Length);
                countRequiredSamples = SumKeyArray(keyBytes);
            }

            keyStream.Seek(0, SeekOrigin.Begin);
            return countRequiredSamples;
        }
Пример #15
0
            public BAR(Stream stream)
            {
                var data = new byte[0x10];
                stream.Read(data, 0, data.Length);

                header.magic = DATA.ByteToInt(data, 0, 4);
                header.count = DATA.ByteToInt(data, 4, 4);
                header.dunno1 = DATA.ByteToInt(data, 8, 4);
                header.dunno2 = DATA.ByteToInt(data, 12, 4);

                if (header.magic != MagicCode)
                    throw new InvalidDataException();

                if (header.count != 0)
                {
                    entries = new Entry[header.count];
                    for (int i = 0; i < header.count; i++)
                    {
                        stream.Read(data, 0, data.Length);
                        entries[i].type = DATA.ByteToInt(data, 0, 4);
                        entries[i].name = DATA.ByteToInt(data, 4, 4);
                        entries[i].position = DATA.ByteToInt(data, 8, 4);
                        entries[i].size = DATA.ByteToInt(data, 12, 4);
                    }
                }
                this.stream = stream;
            }
Пример #16
0
 public ModsDemuxer(Stream Stream)
 {
     this.Stream = Stream;
     Header = new ModsHeader(Stream);
     if (Header.AudioOffset != 0)
     {
         AudioCodebooks = new byte[Header.NbChannel][];
         Stream.Position = Header.AudioOffset;
         for (int i = 0; i < Header.NbChannel; i++)
         {
             AudioCodebooks[i] = new byte[0xC34];
             Stream.Read(AudioCodebooks[i], 0, 0xC34);
         }
     }
     KeyFrames = new KeyFrameInfo[Header.KeyframeCount];
     Stream.Position = Header.KeyframeIndexOffset;
     byte[] tmp = new byte[8];
     for (int i = 0; i < Header.KeyframeCount; i++)
     {
         KeyFrames[i] = new KeyFrameInfo();
         Stream.Read(tmp, 0, 8);
         KeyFrames[i].FrameNumber = IOUtil.ReadU32LE(tmp, 0);
         KeyFrames[i].DataOffset = IOUtil.ReadU32LE(tmp, 4);
     }
     JumpToKeyFrame(0);
 }
Пример #17
0
 public static ICC_Profile GetInstance(Stream file) {
     byte[] head = new byte[128];
     int remain = head.Length;
     int ptr = 0;
     while (remain > 0) {
         int n = file.Read(head, ptr, remain);
         if (n <= 0)
             throw new ArgumentException("Invalid ICC profile");
         remain -= n;
         ptr += n;
     }
     if (head[36] != 0x61 || head[37] != 0x63 
         || head[38] != 0x73 || head[39] != 0x70)
         throw new ArgumentException("Invalid ICC profile");
     remain = ((head[0] & 0xff) << 24) | ((head[1] & 0xff) << 16)
               | ((head[2] & 0xff) <<  8) | (head[3] & 0xff);
     byte[] icc = new byte[remain];
     System.Array.Copy(head, 0, icc, 0, head.Length);
     remain -= head.Length;
     ptr = head.Length;
     while (remain > 0) {
         int n = file.Read(icc, ptr, remain);
         if (n <= 0)
             throw new ArgumentException("Invalid ICC profile");
         remain -= n;
         ptr += n;
     }
     return GetInstance(icc);
 }
        public static int Copy(Stream source, Stream destination, byte[] buffer, int? mask, int count)
        {
            int totalRead = 0, read;
            if(mask == null)
            {
                while (count > 0 && (read = source.Read(buffer, 0, Math.Min(count, buffer.Length))) > 0)
                {
                    destination.Write(buffer, 0, read);
                    totalRead += read;
                    count -= read;
                }
            } else
            {
                int effectiveLength = (buffer.Length/8)*8; // need nice sized! e.g. 100-byte array, can only use 96 bytes
                if(effectiveLength == 0) throw new ArgumentException("buffer is too small to be useful", "buffer");

                // we read it big-endian, so we need to *write* it big-endian, and then we'll use unsafe code to read the value,
                // so that the endian-ness we use is CPU-endian, and so it matches whatever we do below
                int maskValue = mask.Value;
                buffer[0] = buffer[4] = (byte) (maskValue >> 24);
                buffer[1] = buffer[5] = (byte) (maskValue >> 16);
                buffer[2] = buffer[6] = (byte) (maskValue >> 8);
                buffer[3] = buffer[7] = (byte) maskValue;
                unsafe
                {
                    
                    fixed (byte* bufferPtr = buffer) // treat the byte-array as a pile-of-ulongs
                    {
                        var longPtr = (ulong*)bufferPtr;
                        ulong xorMask = *longPtr;
                        int bytesThisIteration;
                        do
                        {
                            // now, need to fill buffer as much as possible each time, as we want to work in exact
                            // units of 8 bytes; we don't need to worry about applying the mask to any garbage at the
                            // end of the buffer, as we simply won't copy that out
                            int offset = 0, available = effectiveLength;
                            while (available > 0 && (read = source.Read(buffer, offset, Math.Min(count, available))) > 0)
                            {
                                available -= read;
                                totalRead += read;
                                count -= read;
                                offset += read;
                            }
                            bytesThisIteration = effectiveLength - available;
                            int chunks = bytesThisIteration/8;
                            if ((available%8) != 0) chunks++;

                            // apply xor 8-bytes at a time, coz we haz 64-bit CPU, baby!
                            for (int i = 0; i < chunks; i++)
                                longPtr[i] ^= xorMask;

                            destination.Write(buffer, 0, bytesThisIteration);
                        } while (bytesThisIteration != 0);
                    }
                }
            }
            if(count != 0) throw new EndOfStreamException();
            return totalRead;
        }
        internal static BEncodedFormatDecodeException CreateTraced(string message, Exception innerException, Stream traceStream)
        {
            StringBuilder traceBuilder = new StringBuilder();
            BEncodedFormatDecodeException exception = new BEncodedFormatDecodeException(message, innerException);

            long seekBack = traceStream.Position > TRACE_SEEK_BACK ? TRACE_SEEK_BACK : traceStream.Position;
            long seekForward = traceStream.Length > (traceStream.Position + TRACE_SEEK_FORWARD) ? TRACE_SEEK_FORWARD : traceStream.Length - traceStream.Position;

            byte[] traceBuffer = new byte[seekBack + seekForward];

            // Back
            traceStream.Seek(seekBack * -1, SeekOrigin.Current);
            traceStream.Read(traceBuffer, 0, (int)seekBack);

            // Forward
            traceStream.Read(traceBuffer, (int)seekBack, (int)seekForward);
            traceStream.Seek(seekForward * -1, SeekOrigin.Current);

            traceBuilder.Append(Encoding.UTF8.GetString(traceBuffer));
            traceBuilder.AppendLine();

            for (int i = 0; i < traceBuffer.Length; i++)
                traceBuilder.Append(i != seekBack ? '-' : '^');

            traceBuilder.Append("    (^ denotes error)");
            traceBuilder.AppendLine();
            traceBuilder.AppendLine();

            exception.decodeTrace = traceBuilder.ToString();

            return exception;
        }
Пример #20
0
		public WavFileStream(Stream stream)
		{
			_stream = stream;
			var bytes = new byte[20];
			if (_stream.Read(bytes, 0, bytes.Length) < bytes.Length ||
				BitConverter.ToInt32(bytes, 4) == 0 ||
				BitConverter.ToInt32(bytes, 8) != 0x45564157 || // "WAVE"
				BitConverter.ToInt32(bytes, 12) != 0x20746d66) // "fmt "
			{
				throw new FileFormatException("Badly formed RIFF file.");
			}
			var fmtBytes = new byte[BitConverter.ToInt32(bytes, 16)];
			_stream.Read(fmtBytes, 0, fmtBytes.Length);
			_format = new WaveFormat(fmtBytes);

			while (_stream.Read(bytes, 0, 8) == 8)
			{
				var dataType = BitConverter.ToInt32(bytes, 0);
				var dataSize = BitConverter.ToInt32(bytes, 4);
				if (dataType == 0x61746164)
				{
					return;
				}
				_stream.Seek(dataSize, SeekOrigin.Current);
			}
			throw new FileFormatException("Could not find wave data.");
		}
Пример #21
0
        private static string GetType(Stream fileStream)
        {
            var buffer = new byte[256];

            // grab the first 256 bytes on the file
            if (fileStream.Length >= 256)
            {
                fileStream.Read(buffer, 0, 256);
            }
            else
            {
                fileStream.Read(buffer, 0, (int)fileStream.Length);
            }

            try
            {
                UInt32 mimeType;
                FindMimeFromData(0, null, buffer, 256, null, 0, out mimeType, 0);
                var mimeTypePointer = new IntPtr(mimeType);
                return Marshal.PtrToStringUni(mimeTypePointer);
            }
            catch (Exception ex)
            {
                return ex.Message;
            }
        }
Пример #22
0
        public string UploadFile(string fileName, Stream content)
        {
            // 我们不知道HTTP请求流的长度,所以我们必须使用以下代码读出流的长度:
            int bufferSize = 4096;
            int bytesRead = 1;
            int totalBytesRead = 0;
            try
            {
                using (FileStream fileStream = File.Create(fileName))
                {
                    byte[] buffer = new byte[bufferSize];
                    bytesRead = content.Read(buffer, 0, bufferSize);
                    while (bytesRead > 0)
                    {
                        fileStream.Write(buffer, 0, bytesRead);
                        bytesRead = content.Read(buffer, 0, bufferSize);
                        totalBytesRead += bytesRead;
                    }
                }

                // 按照REST服务的最近实践,当资源被创建时,返回一个201 Created状态代码代理默认的200.
                // 这意味着Silverlight客户端必须使用HTTP栈,替代默认的浏览器HTTP栈使用服务来工作.
                return WriteResponse(HttpStatusCode.Created, "Created.");
            }
            catch (Exception ex)
            {
                return WriteResponse(HttpStatusCode.InternalServerError, ex.Message);
            }
        }
Пример #23
0
 public ImageMetaData ReadMetaData(Stream stream)
 {
     var header = new byte[0x20];
     if (0x20 != stream.Read(header, 0, 0x20))
         return null;
     if (!Binary.AsciiEqual(header, 0, "xtx\0"))
     {
         var header_size = LittleEndian.ToUInt32(header, 0);
         if (header_size >= 0x1000) // XXX use some arbitrary "large" value to avoid call to Stream.Length
             return null;
         stream.Position = header_size;
         if (0x20 != stream.Read(header, 0, 0x20))
             return null;
         if (!Binary.AsciiEqual(header, 0, "xtx\0"))
             return null;
     }
     if (header[4] > 2)
         return null;
     int aligned_width = BigEndian.ToInt32(header, 8);
     int aligned_height = BigEndian.ToInt32(header, 0xC);
     if (aligned_width <= 0 || aligned_height <= 0)
         return null;
     return new XtxMetaData
     {
         Width = BigEndian.ToUInt32(header, 0x10),
         Height = BigEndian.ToUInt32(header, 0x14),
         OffsetX = BigEndian.ToInt32(header, 0x18),
         OffsetY = BigEndian.ToInt32(header, 0x1C),
         BPP = 32,
         Format = header[4],
         AlignedWidth = aligned_width,
         AlignedHeight = aligned_height,
         DataOffset = (uint)stream.Position,
     };
 }
        private static byte[] ComputeMovieHash(Stream input)
        {
            long streamsize = input.Length;
            long lhash = streamsize;

            long i = 0;

            var buffer
                = new byte[sizeof(long)];

            while (i < 65536 / sizeof(long)
                && (input.Read(buffer, 0, sizeof(long)) > 0))
            {

                i++;
                lhash += BitConverter.ToInt64(buffer, 0);

            }

            input.Position = Math.Max(0, streamsize - 65536);
            i = 0;
            while (i < 65536 / sizeof(long)
                && (input.Read(buffer, 0, sizeof(long)) > 0))
            {

                i++;
                lhash += BitConverter.ToInt64(buffer, 0);

            }

            input.Close();
            byte[] result = BitConverter.GetBytes(lhash);
            Array.Reverse(result);
            return result;
        }
Пример #25
0
        public FrameScanner(Stream input)
        {
            input.Seek(0, SeekOrigin.Begin);
            byte[] frameheadbuffer = new byte[byte.MaxValue + 4];
            byte[] buffer = new byte[6];
            input.Read(buffer, 0, 6);
            headerOkay = Encoding.ASCII.GetString(buffer, 0, 4) == "MMDb";
            if (!headerOkay)
                return;
            version = new Version(buffer[4], buffer[5]);

            if (version == FileVersions.First)
            {
                input.Read(buffer, 0, 4);
                id = BitConverter.ToInt32(buffer, 0);

                while (input.Position < input.Length)
                {
                    byte b = (byte)input.ReadByte();
                    input.Read(frameheadbuffer, 0, 4 + b);
                    FrameIdentifier identifier = new FrameIdentifier(frameheadbuffer, 0, b);
                    int length = BitConverter.ToInt32(frameheadbuffer, b);
                    int position = (int)input.Position;
                    Frame frame = new Frame(position, length, 5 + b);
                    frames.Add(identifier, frame);
                    input.Seek(length, SeekOrigin.Current);
                }
            }
            else
            {
                headerOkay = false;
                return;
            }
        }
Пример #26
0
        public void Upload(TransferInfo transferInfo, Stream data)
        {
            // Compute how much will be left over for the last chunk
            long dataLength = data.Length;
            long chunkSize = SendChunkSize == 0 ? 256000 : SendChunkSize;
            long remainder = dataLength % chunkSize;
            long chunkCount = dataLength / chunkSize;

            // Handle the case of small files
            if (chunkSize >= dataLength)
            {
                chunkSize = dataLength;
                remainder = 0;
                chunkCount = 1;
            }

            string sessionId = m_Proxy.BeginUploadSession(transferInfo);
            for (long index = 0; index < chunkCount; index++)
            {
                byte[] chunk = new byte[chunkSize];
                data.Read(chunk, (int)(index * chunkSize), (int)chunkSize);
                m_Proxy.UploadChunk(sessionId, chunk);
            }
            if (remainder > 0)
            {
                byte[] chunk = new byte[remainder];
                data.Read(chunk, (int)(chunkCount * chunkSize), (int)remainder);
                m_Proxy.UploadChunk(sessionId, chunk);
            }
            m_Proxy.CompleteUpload(sessionId);

        }
Пример #27
0
 public static byte[] ComputeHash(Stream input)
 {
     long length = input.Length;
     ulong num = (ulong)length;
     long num3 = 0L;
     byte[] buffer = new byte[8];
     
     input.Position = 0L;
     
     while ((num3 < 0x2000L) && (input.Read(buffer, 0, 8) > 0))
     {
         num3 += 1L;
         num += BitConverter.ToUInt64(buffer, 0);
     }
     
     input.Position = Math.Max((long)0L, (long)(length - 0x10000L));
     num3 = 0L;
     
     while ((num3 < 0x2000L) && (input.Read(buffer, 0, 8) > 0))
     {
         num3 += 1L;
         num += BitConverter.ToUInt64(buffer, 0);
     }
     
     byte[] bytes = BitConverter.GetBytes(num);
     Array.Reverse(bytes);
     return bytes;
 }
Пример #28
0
 /// <summary>
 /// Returns MIME type of the specified file.
 /// </summary>
 internal static string GetMimeType(Stream fileStream)
 {
   string mime = string.Empty;
   byte[] buffer = new byte[256];
   if (fileStream.Length >= 256)
   {
     fileStream.Read(buffer, 0, 256);
   }
   else
   {
     fileStream.Read(buffer, 0, (int)fileStream.Length);
   }
   try
   {
     UInt32 mimeType;
     ViddlerHelper.FindMimeFromData(0, null, buffer, 256, null, 0, out mimeType, 0);
     IntPtr mimeTypePtr = new IntPtr(mimeType);
     mime = Marshal.PtrToStringUni(mimeTypePtr);
     Marshal.FreeCoTaskMem(mimeTypePtr);
   }
   catch {}
   if (string.IsNullOrEmpty(mime))
   {
     mime = "application/octet-stream";
   }
   return mime;
 }
Пример #29
0
      Stream lStream = fStorage.GetFile(SecureFileName, 0); 
      try
      {

        byte[] lBuffer = new byte[BUFFER_SIZE];
        
        int lBytesRead = lStream.Read(lBuffer, 0, BUFFER_SIZE);
        while (lBytesRead > 0)
        {
          aToStream.Write(lBuffer,0,lBytesRead);
          lBytesRead = lStream.Read(lBuffer, 0, BUFFER_SIZE);
        }
      }
      finally
      {
        lStream.Close();
      }

      //return new FileStream(SecureFileName,FileMode.Open, FileAccess.Read, FileShare.Read);
    }
    const int BUFFER_SIZE = 64*1024;

    public override void CreateFile(Stream aStream)
    {
      if (File.Exists(SecureFileName))
        throw new Exception("Error adding file to secure storage: file already exist.");
      
      //Stream lStream = new FileStream(SecureFileName,FileMode.CreateNew, FileAccess.Write, FileShare.None);
      Stream lStream = fStorage.CreateFile(SecureFileName); 
      try
      {
Пример #30
0
        /// <summary>
        /// Производит дешифрование потока.
        /// </summary>
        /// <param name="inputStream">Поток, который будет дешифрован.</param>
        /// <param name="outputStream">Поток, в который будет записан результат дешифрования.</param>
        /// <param name="Key">Ключ для дешифрования.</param>
        public void DecryptStream(Stream inputStream, Stream outputStream, byte[] Key)
        {
            ThrowIfDisposed();

              if (inputStream == null || outputStream == null || Key == null)
            throw new ArgumentNullException("One of the arguments (or all) equals null");

              int maxBufferSizeValue = bufferCoefficient * ConstBufferCoefficient;

              byte[] originFileLengthArray = new byte[sizeof(long)];
              byte[] iv = new byte[cryptAlgorithm.BlockSize / 8];

              inputStream.Read(originFileLengthArray, 0, sizeof(long));
              inputStream.Read(iv, 0, cryptAlgorithm.BlockSize / 8);

              long deltaLength = inputStream.Length - HeadSize - cryptAlgorithm.BlockSize / 8 - BitConverter.ToInt64(originFileLengthArray, 0);

              using (var transform = cryptAlgorithm.CreateDecryptor(Key, iv))
              {
            using (var csEncrypt = new CryptoStream(inputStream, transform, CryptoStreamMode.Read))
            {
              var dataBuffer = new byte[maxBufferSizeValue];

              while (inputStream.Position < inputStream.Length)
              {
            int dataSize = (inputStream.Length - inputStream.Position > maxBufferSizeValue) ? maxBufferSizeValue : (int)(inputStream.Length - inputStream.Position - deltaLength);

            csEncrypt.Read(dataBuffer, 0, dataSize);
            outputStream.Write(dataBuffer, 0, dataSize);
              }
            }
              }
        }
Пример #31
0
        /// <summary>
        /// 读数据:8字节
        /// </summary>
        /// <returns></returns>
        private long read8(int seek0, int size = 8)
        {
            if (seek0 > 0)
            {
                this.seek(seek0);
            }
            var bytes = new byte[8];

            stream?.Read(bytes, 0, bytes.Length);
            long te = BitConverter.ToInt64(bytes, 0);

            return(te);
        }
Пример #32
0
        void ISocketCallback.Read()
        {
            Interlocked.Increment(ref haveReader);
            try
            {
                do
                {
                    int space     = EnsureSpaceAndComputeBytesToRead();
                    int bytesRead = netStream?.Read(ioBuffer, ioBufferBytes, space) ?? 0;

                    if (!ProcessReadBytes(bytesRead))
                    {
                        return;                               // EOF
                    }
                } while (socketToken.Available != 0);
                Multiplexer.Trace("Buffer exhausted", physicalName);
                // ^^^ note that the socket manager will call us again when there is something to do
            }
            catch (Exception ex)
            {
                RecordConnectionFailed(ConnectionFailureType.InternalFailure, ex);
            }finally
            {
                Interlocked.Decrement(ref haveReader);
            }
        }
Пример #33
0
    public override int Read(byte[] buffer, int offset, int count)
    {
        //Config.Log.LogOut(string.Format("AmazonDriveBaseStream : read pos:{0} count:{1}", pos, count));
        ct.ThrowIfCancellationRequested();
        var ret = innerStream?.Read(buffer, offset, count) ?? -1;

        pos += ret;
        if (pos >= FileSize)
        {
            EOF = true;
        }
        if (EOF && !hashcheck)
        {
            if ((innerStream as IHashStream).Hash.ToLower() != targetItem.contentProperties?.md5)
            {
                Config.Log.LogOut(string.Format("AmazonDriveBaseStream : MD5 ERROR(Server:{0}, download:{1})",
                                                targetItem.contentProperties?.md5,
                                                (innerStream as IHashStream).Hash.ToLower()
                                                ));
                throw new AmazonDriveHashException();
            }
            else
            {
                Config.Log.LogOut("AmazonDriveBaseStream : MD5 OK");
            }
            hashcheck = true;
        }
        return(ret);
    }
Пример #34
0
        public bool Pump()
        {
            using var pooledBuffer = BufferPool.Borrow(MaxBuffer);
            var buffer = pooledBuffer.Data;

            var toRead = CalculateReadBufferSize();

            _readSize = toRead;
            _lastRead = _source?.Read(buffer, 0, toRead) ?? 0;

            if (_lastRead > 0)
            {
                Time(() =>
                     _sinks.ForEach(sink => sink.Write(buffer, _lastRead))
                     );
            }
            else
            {
                if (_disposeAtEnd)
                {
                    _source?.Dispose();
                }

                _source = null;
                _sinks.ForEach(sink => sink.End());
            }

            return(_lastRead > 0);
        }
Пример #35
0
        private static void FileStreamWorkerThread(Stream stream)
        {
            var data    = new byte[188];
            var factory = new TsPacketFactory();

            while (stream?.Read(data, 0, 188) > 0)
            {
                try
                {
                    var tsPackets = factory.GetTsPacketsFromData(data);

                    if (tsPackets == null)
                    {
                        break;
                    }

                    _analyser.AnalysePackets(tsPackets);
                }
                catch (Exception ex)
                {
                    LogMessage($@"Unhandled exception within file streamer: {ex.Message}");
                }
            }

            _pendingExit = true;
            Thread.Sleep(250);

            Console.WriteLine("Completed reading of file - hit enter to exit!");
            Console.ReadLine();
        }
Пример #36
0
        /// <summary>
        /// 上传
        /// </summary>
        /// <param name="requestUrl">请求url</param>
        /// <returns></returns>
        public async Task <Tuple <bool, string> > Upload(String requestUrl, Action <WebClient> config)
        {
            WebClient webClient = new AntDeplopyWebClient
            {
                Timeout = 1000 * 60 * 30
            };//设置超时为20分钟

            webClient.Proxy = null;
            webClient.Headers.Add("Content-Type", "multipart/form-data; boundary=" + boundary);
            webClient.Headers.Add("User-Agent", "antdeploy");
            config?.Invoke(webClient);
            byte[] responseBytes;
            byte[] bytes = MergeContent();

            try
            {
                responseBytes = await webClient.UploadDataTaskAsync(requestUrl, bytes);

                var responseText = System.Text.Encoding.UTF8.GetString(responseBytes);
                if (!string.IsNullOrEmpty(responseText))
                {
                    var model = responseText.JsonToObject <DeployResult>();
                    if (model == null)
                    {
                        return(new Tuple <bool, string>(false, responseText));
                    }

                    if (model.Success)
                    {
                        return(new Tuple <bool, string>(true, "Deploy Success"));
                    }
                    else
                    {
                        return(new Tuple <bool, string>(false, responseText));
                    }
                }
                return(new Tuple <bool, string>(true, responseText));
            }
            catch (WebException ex)
            {
                try
                {
                    Stream responseStream = ex.Response.GetResponseStream();
                    responseBytes = new byte[ex.Response.ContentLength];
                    responseStream?.Read(responseBytes, 0, responseBytes.Length);
                    var responseText2 = System.Text.Encoding.UTF8.GetString(responseBytes);
                    return(new Tuple <bool, string>(false, responseText2));
                }
                catch (Exception)
                {
                    return(new Tuple <bool, string>(false, ex.Message));
                }
            }
            finally
            {
                webClient.Dispose();
            }
        }
Пример #37
0
        /// <summary>
        /// Reads bytes from stream
        /// </summary>
        /// <returns>Number of bytes read or 0 on end of stream</returns>
        public override int Read(byte[] buffer, int offset, int count)
        {
            if (count == 0)
            {
                return(0);
            }
            var guard = buffer[checked ((uint)offset + (uint)count) - 1];

            var action    = LzmaAction.LzmaRun;
            var readCount = 0;

            do
            {
                if (_lzmaStream.avail_in == UIntPtr.Zero)
                {
                    var read = _mInnerStream?.Read(_inbuf, 0, BufSize) ?? 0;
                    if ((uint)read > BufSize)
                    {
                        throw new InvalidDataException();
                    }
                    _lzmaStream.avail_in = (UIntPtr)read;
                    _inbufOffset         = 0;
                    if (read == 0)
                    {
                        action = LzmaAction.LzmaFinish;
                    }
                }

                LzmaReturn ret;
                _lzmaStream.avail_out = (UIntPtr)count;
                fixed(byte *inbuf = &_inbuf[_inbufOffset])
                {
                    _lzmaStream.next_in = inbuf;
                    fixed(byte *outbuf = &buffer[offset])
                    {
                        _lzmaStream.next_out = outbuf;
                        ret = Native.lzma_code(ref _lzmaStream, action);
                    }

                    _inbufOffset += (int)(_lzmaStream.next_in - inbuf);
                }

                if (ret > LzmaReturn.LzmaStreamEnd)
                {
                    throw ThrowError(ret);
                }

                var c = count - (int)(ulong)_lzmaStream.avail_out;
                readCount += c;
                if (ret == LzmaReturn.LzmaStreamEnd)
                {
                    break;
                }
                offset += c;
                count  -= c;
            } while(count != 0);
            return(readCount);
        }
Пример #38
0
        public void ReadStdErrorLoop()
        {
            var buffer = new byte[8192];

            do
            {
                _ffmpegStdErrorStream?.Read(buffer, 0, 8192);
            } while (_isRunning);
        }
Пример #39
0
 /// <summary>
 /// Opens the specified data stream.
 /// </summary>
 /// <param name="dataStream">The data stream.</param>
 /// <param name="firstCluster">The first cluster.</param>
 /// <param name="totalClusters">The total clusters.</param>
 /// <param name="delayWrite">if set to <c>true</c> [delay write].</param>
 public void Open(Stream dataStream, uint firstCluster, long totalClusters, bool delayWrite)
 {
     _dataStream   = dataStream;
     _firstCluster = firstCluster;
     _bitmap       = new byte[(totalClusters + 7) / 8];
     _delayWrite   = delayWrite;
     dataStream?.Read(_bitmap, 0, _bitmap.Length);
     Length = totalClusters;
 }
Пример #40
0
        public override int Read(byte[] buffer, int offset, int count)
        {
            int readResult = bufferStream?.Read(buffer, offset, count) ?? default(int);

            if (readResult == default(int) && !writeFinished)
            {
                FillBuffer();
                readResult = bufferStream.Read(buffer, offset, count);
            }

            return(readResult);
        }
Пример #41
0
        public Packet ReceiveOnce(int bufferSize = 4096)
        {
            if (Stream == null || !_socket.Connected)
            {
                return(null);
            }

            byte[] bytes  = new byte[bufferSize];
            int    length = (Stream?.Read(bytes, 0, bytes.Length)).Value;

            return(new Packet(new List <byte>(bytes).GetRange(0, length)));
        }
Пример #42
0
        FilterStatus IResponseFilter.Filter(Stream dataIn, out long dataInRead, Stream dataOut, out long dataOutWritten)
        {
            int responseLength = responseData.Length;

            if (state == State.Reading)
            {
                int bytesToRead = Math.Min(responseLength - offset, (int)Math.Min(dataIn?.Length ?? 0, int.MaxValue));

                dataIn?.Read(responseData, offset, bytesToRead);
                offset += bytesToRead;

                dataInRead     = bytesToRead;
                dataOutWritten = 0;

                if (offset >= responseLength)
                {
                    responseData = encoding.GetBytes(ProcessResponse(encoding.GetString(responseData)));
                    state        = State.Writing;
                    offset       = 0;
                }

                return(FilterStatus.NeedMoreData);
            }
            else if (state == State.Writing)
            {
                int bytesToWrite = Math.Min(responseLength - offset, (int)Math.Min(dataOut.Length, int.MaxValue));

                if (bytesToWrite > 0)
                {
                    dataOut.Write(responseData, offset, bytesToWrite);
                    offset += bytesToWrite;
                }

                dataOutWritten = bytesToWrite;
                dataInRead     = 0;

                if (offset < responseLength)
                {
                    return(FilterStatus.NeedMoreData);
                }
                else
                {
                    state = State.Done;
                    return(FilterStatus.Done);
                }
            }
            else
            {
                throw new InvalidOperationException("This resource filter cannot be reused.");
            }
        }
Пример #43
0
        private void HandleResponse(IAsyncResult result)
        {
            byte[] data;

            using (HttpWebResponse response = (HttpWebResponse)_httpWebRequest.EndGetResponse(result))
            {
                if (response.StatusCode != HttpStatusCode.OK)
                {
                    Console.WriteLine("error reaching tracker " + this + ": " + response.StatusCode + " " + response.StatusDescription);
                    return;
                }

                using (Stream stream = response.GetResponseStream())
                {
                    data = new byte[response.ContentLength];
                    stream?.Read(data, 0, Convert.ToInt32(response.ContentLength));
                }
            }

            Dictionary <string, object> info = BenCoding.Decode(data) as Dictionary <string, object>;

            if (info == null)
            {
                Console.WriteLine("unable to decode tracker announce response");
                return;
            }

            PeerRequestInterval = TimeSpan.FromSeconds((long)info["interval"]);
            byte[] peerInfo = (byte[])info["peers"];

            List <IPEndPoint> peers = new List <IPEndPoint>();

            for (int i = 0; i < peerInfo.Length / 6; i++)
            {
                int    offset  = i * 6;
                string address = peerInfo[offset] + "." + peerInfo[offset + 1] + "." + peerInfo[offset + 2] + "." + peerInfo[offset + 3];
                int    port    = EndianBitConverter.Big.ToChar(peerInfo, offset + 4);

                peers.Add(new IPEndPoint(IPAddress.Parse(address), port));
            }

            var handler = PeerListUpdated;

            handler?.Invoke(this, peers);
        }
Пример #44
0
        public FilterStatus Filter(Stream? dataIn, out long dataInRead, Stream dataOut, long dataOutLength, out long dataOutWritten)
        {
            int responseLength = responseData.Length;

            if (state == State.Reading) {
                int bytesToRead = Math.Min(responseLength - offset, (int) Math.Min(dataIn?.Length ?? 0, int.MaxValue));
                int bytesRead = dataIn?.Read(responseData, offset, bytesToRead) ?? 0;

                offset += bytesRead;
                dataInRead = bytesRead;
                dataOutWritten = 0;

                if (offset >= responseLength) {
                    responseData = processor.Process(responseData);
                    state = State.Writing;
                    offset = 0;
                }

                return FilterStatus.NeedMoreData;
            }
            else if (state == State.Writing) {
                int bytesToWrite = Math.Min(responseLength - offset, (int) Math.Min(dataOutLength, int.MaxValue));

                if (bytesToWrite > 0) {
                    dataOut.Write(responseData, offset, bytesToWrite);
                    offset += bytesToWrite;
                }

                dataOutWritten = bytesToWrite;
                dataInRead = 0;

                if (offset < responseLength) {
                    return FilterStatus.NeedMoreData;
                }
                else {
                    state = State.Done;
                    return FilterStatus.Done;
                }
            }
            else {
                throw new InvalidOperationException("This resource filter cannot be reused!");
            }
        }
Пример #45
0
        /// <summary>
        /// 读取请求返回的数据
        /// </summary>
        /// <param name="request">请求对象</param>
        /// <returns></returns>
        private byte[] GetData(HttpWebRequest request)
        {
            //HttpWebResponse response = (HttpWebResponse)request.GetResponse();
            HttpWebResponse response;

            try
            {
                response = (HttpWebResponse)request.GetResponse();
            }
            catch (WebException ex)
            {
                response = (HttpWebResponse)ex.Response;
            }
            Stream stream = response.GetResponseStream();

            responseHeaders = response.Headers;
            //SaveCookiesToDisk();

            DownloadEventArgs args = new DownloadEventArgs();

            if (responseHeaders[HttpResponseHeader.ContentLength] != null)
            {
                args.TotalBytes = Convert.ToInt32(responseHeaders[HttpResponseHeader.ContentLength]);
            }

            MemoryStream ms    = new MemoryStream();
            int          count = 0;

            byte[] buf = new byte[bufferSize];
            while ((count = stream.Read(buf, 0, buf.Length)) > 0)
            {
                ms.Write(buf, 0, count);
                if (this.DownloadProgressChanged != null)
                {
                    args.BytesReceived += count;
                    args.ReceivedData   = new byte[count];
                    Array.Copy(buf, args.ReceivedData, count);
                    this.DownloadProgressChanged(this, args);
                }
            }
            stream.Close();
            //解压
            if (ResponseHeaders[HttpResponseHeader.ContentEncoding] != null)
            {
                MemoryStream msTemp = new MemoryStream();
                count = 0;
                buf   = new byte[100];
                switch (ResponseHeaders[HttpResponseHeader.ContentEncoding].ToLower())
                {
                case "gzip":
                    GZipStream gzip = new GZipStream(ms, CompressionMode.Decompress);
                    while ((count = gzip.Read(buf, 0, buf.Length)) > 0)
                    {
                        msTemp.Write(buf, 0, count);
                    }
                    return(msTemp.ToArray());

                case "deflate":
                    DeflateStream deflate = new DeflateStream(ms, CompressionMode.Decompress);
                    while ((count = deflate.Read(buf, 0, buf.Length)) > 0)
                    {
                        msTemp.Write(buf, 0, count);
                    }
                    return(msTemp.ToArray());

                default:
                    break;
                }
            }
            return(ms.ToArray());
        }
Пример #46
0
 /// <summary>
 /// Reads data from a stream into the provided buffer.
 /// </summary>
 /// <param name="stream">The stream.</param>
 /// <param name="buffer">The buffer.</param>
 /// <param name="offset">The offset within the buffer where the bytes are read into.</param>
 /// <param name="count">The number of bytes, if available, to read.</param>
 /// <returns>The actual number of bytes read.</returns>
 public static int Read(this Stream stream, Span <byte> buffer, int offset, int count)
 => stream.Read(buffer.Slice(offset, count));
Пример #47
0
        public int DoDownloadFile(string remoteFilename, string localFilename, string httpUsername, string httpPassword, out bool success)
        {
            // Function will return the number of bytes processed
            // to the caller. Initialize to 0 here.
            var bytesProcessed = 0;

            success = true;

            // Assign values to these objects here so that they can
            // be referenced in the finally block
            Stream      remoteStream = null;
            Stream      localStream  = null;
            WebResponse response     = null;

            // Use a try/catch/finally block as both the WebRequest and Stream
            // classes throw exceptions upon error
            try
            {
                // Create a request for the specified remote file name
                var request = WebRequest.Create(remoteFilename);
                // If a username or password have been given, use them
                if (!string.IsNullOrEmpty(httpUsername) || !string.IsNullOrEmpty(httpPassword))
                {
                    var username = httpUsername;
                    var password = httpPassword;
                    request.Credentials = new NetworkCredential(username, password);
                }

                // Send the request to the server and retrieve the
                // WebResponse object
                response = request.GetResponse();
                // Once the WebResponse object has been retrieved,
                // get the stream object associated with the response's data
                remoteStream = response.GetResponseStream();

                // Create the local file
                localStream = File.Create(localFilename);

                // Allocate a 1k buffer
                var buffer = new byte[1024];
                int bytesRead;

                // Simple do/while loop to read from stream until
                // no bytes are returned
                do
                {
                    // Read data (up to 1k) from the stream
                    bytesRead = remoteStream?.Read(buffer, 0, buffer.Length) ?? 0;

                    // Write the data to the local file
                    localStream.Write(buffer, 0, bytesRead);

                    // Increment total bytes processed
                    bytesProcessed += bytesRead;
                } while (bytesRead > 0);
            }
            catch (WebException wex)
            {
                if (wex.Status == WebExceptionStatus.ConnectFailure || wex.Status == WebExceptionStatus.NameResolutionFailure)
                {
                    // We probably don't have a network connection (despite the check in the caller).
                    if (File.Exists(localFilename))
                    {
                        Log.LogWarning("Could not retrieve latest {0}. No network connection. Keeping existing file.", localFilename);
                    }
                    else
                    {
                        Log.LogError("Could not retrieve latest {0}. No network connection.", remoteFilename);
                        success = false;                         // Presumably can't continue
                    }
                    return(0);
                }

                if (wex.Response != null)
                {
                    string html;
                    // ReSharper disable once AssignNullToNotNullAttribute
                    using (var sr = new StreamReader(wex.Response.GetResponseStream()))
                        html = sr.ReadToEnd();
                    Log.LogError("Could not download from {0}. Server responds {1}", remoteFilename, html);
                }
                else
                {
                    Log.LogError("Could not download from {0}. no server response. Exception {1}. Status {2}",
                                 remoteFilename, wex.Message, wex.Status);
                }
                success = false;
                return(0);
            }
            catch (Exception e)
            {
                Log.LogError(e.Message);
                Log.LogMessage(MessageImportance.Normal, e.StackTrace);
                success = false;
            }
            finally
            {
                // Close the response and streams objects here
                // to make sure they're closed even if an exception
                // is thrown at some point
                response?.Close();
                remoteStream?.Close();
                localStream?.Close();
            }

            // Return total bytes processed to caller.
            return(bytesProcessed);
        }
Пример #48
0
        static unsafe Encoding AutoDetectEncoding(Stream stream)
        {
            try {
                int    max        = (int)System.Math.Min(stream.Length, 50 * 1024);
                byte[] readBuf    = new byte[max];
                int    readLength = stream.Read(readBuf, 0, max);
                stream.Position = 0;

                // Store the dfa data from the verifiers in local variables.
                byte[] states           = new byte[verifiers.Length];
                int    verifiersRunning = verifiers.Length;

                for (int i = 0; i < verifiers.Length; i++)
                {
                    states [i] = verifiers [i].InitalState;

                    // run the verifiers
                    fixed(byte *bBeginPtr = readBuf, stateBeginPtr = states)
                    {
                        byte *bPtr    = bBeginPtr;
                        byte *bEndPtr = bBeginPtr + readLength;
                        byte *sEndPtr = stateBeginPtr + states.Length;

                        while (bPtr != bEndPtr)
                        {
                            byte *sPtr = stateBeginPtr;
                            int   i    = 0;
                            while (sPtr != sEndPtr)
                            {
                                byte curState = *sPtr;
                                if (curState != 0)
                                {
                                    curState = stateTables [i] [curState] [*bPtr];
                                    if (curState == 0)
                                    {
                                        verifiersRunning--;
                                        if (verifiersRunning == 0)
                                        {
                                            goto finishVerify;
                                        }
                                    }
                                    *sPtr = curState;
                                }
                                sPtr++;
                                i++;
                            }
                            bPtr++;
                        }
finishVerify:
                        if (verifiersRunning > 0)
                        {
//						Console.WriteLine ("valid encodings:");
//						for (int i = 0; i < verifiers.Length; i++) {
//							if (verifiers [i].IsEncodingValid (states [i]))
//								Console.WriteLine (verifiers [i].Encoding.EncodingName);
//						}
//						Console.WriteLine ("---------------");
                            for (int i = 0; i < verifiers.Length; i++)
                            {
                                if (verifiers [i].IsEncodingValid(states [i]))
                                {
                                    return(verifiers [i].Encoding);
                                }
                            }
                        }
                    }
            } catch (Exception e) {
                Console.WriteLine(e);
            }
            return(Encoding.ASCII);
        }
Пример #49
0
 public static void Read(this Stream stream, IManagedByteBuffer buffer)
 => stream.Read(buffer.Array, 0, buffer.Length());
Пример #50
0
        /// <summary>
        /// Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.
        /// </summary>
        /// <param name="buffer">An array of bytes. When this method returns, the buffer contains the specified byte array with the values between offset and (offset + count - 1) replaced by the bytes read from the current source.</param>
        /// <param name="offset">The zero-based byte offset in buffer at which to begin storing the data read from the current stream.</param>
        /// <param name="count">The maximum number of bytes to be read from the current stream.</param>
        /// <returns>The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many bytes are not currently available, or zero (0) if the end of the stream has been reached.</returns>
        /// <exception cref="ObjectDisposedException">Is raised when this object is disposed and this method is accessed.</exception>
        /// <exception cref="ArgumentNullException">Is raised when <b>buffer</b> is null reference.</exception>
        /// <exception cref="ArgumentOutOfRangeException">Is raised when any of the arguments has out of valid range.</exception>
        /// <exception cref="NotSupportedException">Is raised when reading not supported.</exception>
        public override int Read(byte[] buffer, int offset, int count)
        {
            if (m_IsDisposed)
            {
                throw new ObjectDisposedException("Base64Stream");
            }
            if (buffer == null)
            {
                throw new ArgumentNullException("buffer");
            }
            if (offset < 0)
            {
                throw new ArgumentOutOfRangeException("offset", "Argument 'offset' value must be >= 0.");
            }
            if (count < 0)
            {
                throw new ArgumentOutOfRangeException("count", "Argument 'count' value must be >= 0.");
            }
            if (offset + count > buffer.Length)
            {
                throw new ArgumentOutOfRangeException("count", "Argument 'count' is bigger than than argument 'buffer' can store.");
            }
            if ((m_AccessMode & FileAccess.Read) == 0)
            {
                throw new NotSupportedException();
            }

            // We havn't any decoded data left, decode new data block.
            if ((m_DecodedBlockCount - m_DecodedBlockOffset) == 0)
            {
                byte[] readBuffer  = new byte[m_pDecodedBlock.Length + 3];
                int    readedCount = m_pStream.Read(readBuffer, 0, readBuffer.Length - 3);
                // We reached end of stream, no more data.
                if (readedCount == 0)
                {
                    return(0);
                }

                // Decode block must contain only integral 4-byte base64 blocks.
                // Count base64 chars.
                int base64Count = 0;
                for (int i = 0; i < readedCount; i++)
                {
                    byte b = readBuffer[i];
                    if (b == '=' || BASE64_DECODE_TABLE[b] != -1)
                    {
                        base64Count++;
                    }
                }
                // Read while last block is full 4-byte base64 block.
                while ((base64Count % 4) != 0)
                {
                    int b = m_pStream.ReadByte();
                    // End of stream reached.
                    if (b == -1)
                    {
                        break;
                    }
                    else if (b == '=' || BASE64_DECODE_TABLE[b] != -1)
                    {
                        readBuffer[readedCount++] = (byte)b;
                        base64Count++;
                    }
                }

                // Decode block.
                m_DecodedBlockCount  = m_pBase64.Decode(readBuffer, 0, readedCount, m_pDecodedBlock, 0, true);
                m_DecodedBlockOffset = 0;
            }

            int available   = m_DecodedBlockCount - m_DecodedBlockOffset;
            int countToCopy = Math.Min(count, available);

            Array.Copy(m_pDecodedBlock, m_DecodedBlockOffset, buffer, offset, countToCopy);
            m_DecodedBlockOffset += countToCopy;

            return(countToCopy);
        }
Пример #51
0
        public AFile Parse(Stream stream)
        {
            EndianBitConverter bc    = EndianBitConverter.CreateForLittleEndian();
            EndianBitConverter bcBig = EndianBitConverter.CreateForBigEndian();
            bool isDvd = false;

            AFile aFile = new AFile();

            aFile.MDSPath = (stream as FileStream).Name;

            stream.Seek(0, SeekOrigin.Begin);

            // check whether the header in the mds file is long enough
            if (stream.Length < 88)
            {
                throw new MDSParseException("Malformed MDS format: The descriptor file does not appear to be long enough.");
            }

            // parse header
            aFile.Header = aFile.Header.Parse(stream);

            // check version to make sure this is only v1.x
            // currently NO support for version 2.x

            if (aFile.Header.Version[0] > 1)
            {
                throw new MDSParseException($"MDS Parse Error: Only MDS version 1.x is supported!\nDetected version: {aFile.Header.Version[0]}.{aFile.Header.Version[1]}");
            }

            // parse sessions
            Dictionary <int, ASession> aSessions = new Dictionary <int, ASession>();

            stream.Seek(aFile.Header.SessionOffset, SeekOrigin.Begin);
            for (int se = 0; se < aFile.Header.SessionCount; se++)
            {
                byte[] sessionHeader = new byte[24];
                stream.Read(sessionHeader, 0, 24);
                //sessionHeader.Reverse().ToArray();

                ASession session = new ASession();

                session.SessionStart   = bc.ToInt32(sessionHeader.Take(4).ToArray());
                session.SessionEnd     = bc.ToInt32(sessionHeader.Skip(4).Take(4).ToArray());
                session.SessionNumber  = bc.ToInt16(sessionHeader.Skip(8).Take(2).ToArray());
                session.AllBlocks      = sessionHeader[10];
                session.NonTrackBlocks = sessionHeader[11];
                session.FirstTrack     = bc.ToInt16(sessionHeader.Skip(12).Take(2).ToArray());
                session.LastTrack      = bc.ToInt16(sessionHeader.Skip(14).Take(2).ToArray());
                session.TrackOffset    = bc.ToInt32(sessionHeader.Skip(20).Take(4).ToArray());


                //mdsf.Sessions.Add(session);
                aSessions.Add(session.SessionNumber, session);
            }

            long footerOffset = 0;

            // parse track blocks
            Dictionary <int, ATrack> aTracks = new Dictionary <int, ATrack>();

            // iterate through each session block
            foreach (ASession session in aSessions.Values)
            {
                stream.Seek(session.TrackOffset, SeekOrigin.Begin);
                //Dictionary<int, ATrack> sessionToc = new Dictionary<int, ATrack>();

                // iterate through every block specified in each session
                for (int bl = 0; bl < session.AllBlocks; bl++)
                {
                    byte[] trackHeader;
                    ATrack track = new ATrack();

                    trackHeader = new byte[80];

                    stream.Read(trackHeader, 0, 80);

                    track.Mode         = trackHeader[0];
                    track.SubMode      = trackHeader[1];
                    track.ADR_Control  = trackHeader[2];
                    track.TrackNo      = trackHeader[3];
                    track.Point        = trackHeader[4];
                    track.AMin         = trackHeader[5];
                    track.ASec         = trackHeader[6];
                    track.AFrame       = trackHeader[7];
                    track.Zero         = trackHeader[8];
                    track.PMin         = trackHeader[9];
                    track.PSec         = trackHeader[10];
                    track.PFrame       = trackHeader[11];
                    track.ExtraOffset  = bc.ToInt32(trackHeader.Skip(12).Take(4).ToArray());
                    track.SectorSize   = bc.ToInt16(trackHeader.Skip(16).Take(2).ToArray());
                    track.PLBA         = bc.ToInt32(trackHeader.Skip(36).Take(4).ToArray());
                    track.StartOffset  = BitConverter.ToUInt64(trackHeader.Skip(40).Take(8).ToArray(), 0);
                    track.Files        = bc.ToInt32(trackHeader.Skip(48).Take(4).ToArray());
                    track.FooterOffset = bc.ToInt32(trackHeader.Skip(52).Take(4).ToArray());

                    if (track.Mode == 0x02)
                    {
                        isDvd = true;
                        throw new MDSParseException("DVD Detected. Not currently supported!");
                    }


                    // check for track extra block - this can probably be handled in a separate loop,
                    // but I'll just store the current stream position then seek forward to the extra block for this track
                    Int64 currPos = stream.Position;

                    // Only CDs have extra blocks - for DVDs ExtraOffset = track length
                    if (track.ExtraOffset > 0 && !isDvd)
                    {
                        byte[] extHeader = new byte[8];
                        stream.Seek(track.ExtraOffset, SeekOrigin.Begin);
                        stream.Read(extHeader, 0, 8);
                        track.ExtraBlock.Pregap  = bc.ToInt32(extHeader.Take(4).ToArray());
                        track.ExtraBlock.Sectors = bc.ToInt32(extHeader.Skip(4).Take(4).ToArray());
                        stream.Seek(currPos, SeekOrigin.Begin);
                    }
                    else if (isDvd == true)
                    {
                        track.ExtraBlock.Sectors = track.ExtraOffset;
                    }

                    // read the footer/filename block for this track
                    currPos = stream.Position;
                    long numOfFilenames = track.Files;
                    for (long fi = 1; fi <= numOfFilenames; fi++)
                    {
                        // skip leadin/out info tracks
                        if (track.FooterOffset == 0)
                        {
                            continue;
                        }

                        byte[] foot = new byte[16];
                        stream.Seek(track.FooterOffset, SeekOrigin.Begin);
                        stream.Read(foot, 0, 16);

                        AFooter f = new AFooter();
                        f.FilenameOffset = bc.ToInt32(foot.Take(4).ToArray());
                        f.WideChar       = bc.ToInt32(foot.Skip(4).Take(4).ToArray());
                        track.FooterBlocks.Add(f);
                        track.FooterBlocks = track.FooterBlocks.Distinct().ToList();

                        // parse the filename string
                        string fileName = "*.mdf";
                        if (f.FilenameOffset > 0)
                        {
                            // filename offset is present
                            stream.Seek(f.FilenameOffset, SeekOrigin.Begin);
                            byte[] fname;

                            if (numOfFilenames == 1)
                            {
                                if (aFile.Header.DPMOffset == 0)
                                {
                                    // filename is in the remaining space to EOF
                                    fname = new byte[stream.Length - stream.Position];
                                }
                                else
                                {
                                    // filename is in the remaining space to EOF + dpm offset
                                    fname = new byte[aFile.Header.DPMOffset - stream.Position];
                                }
                            }

                            else
                            {
                                // looks like each filename string is 6 bytes with a trailing \0
                                fname = new byte[6];
                            }


                            // read the filename
                            stream.Read(fname, 0, fname.Length);

                            // if widechar is 1 filename is stored using 16-bit, otherwise 8-bit is used
                            if (f.WideChar == 1)
                            {
                                fileName = Encoding.Unicode.GetString(fname).TrimEnd('\0');
                            }
                            else
                            {
                                fileName = Encoding.Default.GetString(fname).TrimEnd('\0');
                            }
                        }

                        else
                        {
                            // assume an MDF file with the same name as the MDS
                        }

                        string dir = Path.GetDirectoryName(aFile.MDSPath);

                        if (f.FilenameOffset == 0 ||
                            string.Compare(fileName, "*.mdf", StringComparison.InvariantCultureIgnoreCase) == 0)
                        {
                            fileName = $@"{dir}\{Path.GetFileNameWithoutExtension(aFile.MDSPath)}.mdf";
                        }
                        else
                        {
                            fileName = $@"{dir}\{fileName}";
                        }

                        track.ImageFileNamePaths.Add(fileName);
                        track.ImageFileNamePaths = track.ImageFileNamePaths.Distinct().ToList();
                    }

                    stream.Position = currPos;


                    aTracks.Add(track.Point, track);
                    aFile.Tracks.Add(track);

                    if (footerOffset == 0)
                    {
                        footerOffset = track.FooterOffset;
                    }
                }
            }


            // build custom session object
            aFile.ParsedSession = new List <Session>();
            foreach (var s in aSessions.Values)
            {
                Session session = new Session();
                ATrack  startTrack;
                ATrack  endTrack;

                if (!aTracks.TryGetValue(s.FirstTrack, out startTrack))
                {
                    break;
                }

                if (!aTracks.TryGetValue(s.LastTrack, out endTrack))
                {
                    break;
                }

                session.StartSector     = startTrack.PLBA;
                session.StartTrack      = s.FirstTrack;
                session.SessionSequence = s.SessionNumber;
                session.EndSector       = endTrack.PLBA + endTrack.ExtraBlock.Sectors - 1;
                session.EndTrack        = s.LastTrack;

                aFile.ParsedSession.Add(session);
            }

            // now build the TOC object
            foreach (var se in aFile.ParsedSession)
            {
                foreach (var t in aTracks.Values
                         .Where(a => se.StartTrack <= a.TrackNo && a.TrackNo <= se.EndTrack)
                         .OrderBy(a => a.TrackNo))
                {
                    aFile.TOCEntries.Add(new ATOCEntry(t.Point)
                    {
                        ADR_Control        = t.ADR_Control,
                        AFrame             = t.AFrame,
                        AMin               = t.AMin,
                        ASec               = t.ASec,
                        BlobIndex          = t.BlobIndex,
                        EntryNum           = t.TrackNo,
                        ExtraBlock         = t.ExtraBlock,
                        ImageFileNamePaths = t.ImageFileNamePaths,
                        PFrame             = t.PFrame,
                        PLBA               = Convert.ToInt32(t.PLBA),
                        PMin               = t.PMin,
                        Point              = t.Point,
                        PSec               = t.PSec,
                        SectorSize         = t.SectorSize,
                        Session            = se.SessionSequence,
                        TrackOffset        = Convert.ToInt64(t.StartOffset),
                        Zero               = t.Zero
                    });
                }
            }

            return(aFile);
        }
Пример #52
0
        public static float ReadFloat(this Stream stream)
        {
            stream.Read(data, 0, 4);

            return(BitConverter.ToSingle(data, 0));
        }
Пример #53
0
        public static UInt64 ReadUInt64(this Stream stream)
        {
            stream.Read(data, 0, 8);

            return(BitConverter.ToUInt64(data, 0));
        }
Пример #54
0
        public static UInt16 ReadUInt16(this Stream stream)
        {
            stream.Read(data, 0, 2);

            return(BitConverter.ToUInt16(data, 0));
        }
Пример #55
0
 public override int Read(byte[] buffer, int offset, int count)
 {
     return(_wrapped.Read(buffer, offset, count));
 }
Пример #56
0
        public static UInt32 ReadUInt32(this Stream stream)
        {
            stream.Read(data, 0, 4);

            return(BitConverter.ToUInt32(data, 0));
        }
Пример #57
0
        /// <summary>
        /// 上传
        /// </summary>
        /// <returns></returns>
        public async Task <Tuple <bool, string> > Upload(String requestUrl, Action <long> progress, IWebProxy proxy = null)
        {
            byte[] bytes = MergeContent();
            try
            {
                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(requestUrl);
                if (proxy != null)
                {
                    request.Proxy = proxy;
                }
                request.Method = "POST";
                request.AllowWriteStreamBuffering = false;
                request.AllowReadStreamBuffering  = false;
                request.ContentLength             = bytes.Length;
                request.ContentType = "multipart/form-data; boundary=" + boundary;
                using (var req = await request.GetRequestStreamAsync())
                {
                    var bytesArr = BufferSplit(bytes, 4096);
                    var i        = 0;
                    foreach (var arr in bytesArr)
                    {
                        await req.WriteAsync(arr, 0, arr.Length);

                        i += arr.Length;
                        await req.FlushAsync(); // flushing is required or else we jump to 100% very fast

                        progress?.Invoke((int)(100.0 * i / bytes.Length));
                    }
                }

                HttpWebResponse WResp = (HttpWebResponse)request.GetResponse();
                using (Stream stream = WResp.GetResponseStream())
                {
                    var reader       = new StreamReader(stream);
                    var responseText = reader.ReadToEnd();


                    if (!string.IsNullOrEmpty(responseText))
                    {
                        var model = responseText.JsonToObject <DeployResult>();
                        if (model == null)
                        {
                            return(new Tuple <bool, string>(false, responseText));
                        }

                        if (model.Success)
                        {
                            return(new Tuple <bool, string>(true, "Deploy Success"));
                        }
                        else
                        {
                            return(new Tuple <bool, string>(false, responseText));
                        }
                    }
                }
                WResp.Close();
                return(new Tuple <bool, string>(true, "Deploy Fail"));
            }
            catch (WebException ex)
            {
                try
                {
                    Stream responseStream = ex.Response.GetResponseStream();
                    byte[] responseBytes  = new byte[ex.Response.ContentLength];
                    responseStream?.Read(responseBytes, 0, responseBytes.Length);
                    var responseText2 = System.Text.Encoding.UTF8.GetString(responseBytes);
                    return(new Tuple <bool, string>(false, responseText2 + "==>exception:" + ex.Message));
                }
                catch (Exception)
                {
                    return(new Tuple <bool, string>(false, ex.Message));
                }
            }
            catch (Exception ex1)
            {
                return(new Tuple <bool, string>(false, ex1.Message));
            }
            finally
            {
                bytesArray = null;
            }
        }
Пример #58
0
 public void Get(ref EdiDBContext _DbO, ref int _CodError, ref string _MessageSubject, ref string _FileName, ref List<string> _EdiPure)
 {
     try
     {
         GetInStack(ref _DbO, ref _CodError, ref _MessageSubject);
         if (Files.Length == 0)
             return;
         if (string.IsNullOrEmpty(Files.LastOrDefault()))
             return;
         List<string> ListFiles = Files.ToList();
         List<LearPureEdi> ListLearPureEdiO = (
             from Pe in _DbO.LearPureEdi
             from Lf in ListFiles
             where Pe.NombreArchivo == Lf
             select Pe).ToList();
         for(int Ci = 0; Ci < ListLearPureEdiO.Count; Ci++)
         {
             if (ListLearPureEdiO[Ci].Reprocesar)
             {
                 ListLearPureEdiO[Ci].Reprocesar = false;
                 _DbO.LearPureEdi.Update(ListLearPureEdiO[Ci]);
                 _DbO.SaveChanges();
                 _FileName = ListLearPureEdiO[Ci].NombreArchivo;                        
                 break;
             }
             ListFiles.Remove(ListLearPureEdiO[Ci].NombreArchivo);
         }
         if (string.IsNullOrEmpty(_FileName))
         {
             if (ListFiles.Count == 0)
             {
                 _CodError = -2;
                 return;
             }
             else {
                 _FileName = ListFiles.Fod();
             }
         }
         ftpRequest = UseHost2 ? (FtpWebRequest)WebRequest.Create($"{host2}/{DirIn}/{_FileName}") : (FtpWebRequest)WebRequest.Create($"{host}/{DirIn}/{_FileName}");
         ftpRequest.Credentials = new NetworkCredential(user, pass);
         ftpRequest.UseBinary = true;
         ftpRequest.UsePassive = true;
         ftpRequest.KeepAlive = true;
         ftpRequest.Method = WebRequestMethods.Ftp.DownloadFile;
         ftpResponse = (FtpWebResponse)ftpRequest.GetResponse();
         ftpStream = ftpResponse.GetResponseStream();
         MemoryStream localFileStream = new MemoryStream();
         byte[] byteBuffer = new byte[bufferSize];
         int bytesRead = ftpStream.Read(byteBuffer, 0, bufferSize);
         try
         {
             while (bytesRead > 0)
             {
                 localFileStream.Write(byteBuffer, 0, bytesRead);
                 bytesRead = ftpStream.Read(byteBuffer, 0, bufferSize);                        
             }
         }
         catch (Exception ex)
         {
             _CodError = -9;
             _MessageSubject = $"Error, al escribir el archivo en stream de memoria {_FileName} en ftp {(UseHost2 ? host2 : host)}. Info: {ex.ToString()}";
             AddComLog(ref _DbO, Id, _MessageSubject);
             return;
         }
         localFileStream.Close();
         ftpStream.Close();
         ftpResponse.Close();
         ftpRequest = null;
         string EdiPure2 = System.Text.Encoding.UTF8.GetString(localFileStream.ToArray());
         _EdiPure = EdiPure2.Split(EdiBase.SegmentTerminator).ToList();
         if (_EdiPure.Count == 1)
             _EdiPure = EdiPure2.Split('\n').ToList();
         AddComLog(ref _DbO, Id, $"Se obtuvo el archivo {_FileName} de ftp {(UseHost2 ? host2 : host)}");
         return;
     }
     catch (Exception ex)
     {
         _CodError = -10;
         _MessageSubject = $"Error en método GET en ftp {(UseHost2 ? host2 : host)}. Info: {ex.ToString()}";
         AddComLog(ref _DbO, Id, _MessageSubject);
         return;
     }
 }
Пример #59
0
        public bool Open(IFilter imageFilter)
        {
            Stream stream = imageFilter.GetDataForkStream();

            stream.Seek(0, SeekOrigin.Begin);
            byte[] buffer  = new byte[0x58];
            byte[] pString = new byte[64];
            stream.Read(buffer, 0, 0x58);
            IsWriting = false;

            // Incorrect pascal string length, not DC42
            if (buffer[0] > 63)
            {
                return(false);
            }

            header = new Dc42Header();
            BigEndianBitConverter.IsLittleEndian = BitConverter.IsLittleEndian;

            Array.Copy(buffer, 0, pString, 0, 64);
            header.DiskName     = StringHandlers.PascalToString(pString, Encoding.GetEncoding("macintosh"));
            header.DataSize     = BigEndianBitConverter.ToUInt32(buffer, 0x40);
            header.TagSize      = BigEndianBitConverter.ToUInt32(buffer, 0x44);
            header.DataChecksum = BigEndianBitConverter.ToUInt32(buffer, 0x48);
            header.TagChecksum  = BigEndianBitConverter.ToUInt32(buffer, 0x4C);
            header.Format       = buffer[0x50];
            header.FmtByte      = buffer[0x51];
            header.Valid        = buffer[0x52];
            header.Reserved     = buffer[0x53];

            DicConsole.DebugWriteLine("DC42 plugin", "header.diskName = \"{0}\"", header.DiskName);
            DicConsole.DebugWriteLine("DC42 plugin", "header.dataSize = {0} bytes", header.DataSize);
            DicConsole.DebugWriteLine("DC42 plugin", "header.tagSize = {0} bytes", header.TagSize);
            DicConsole.DebugWriteLine("DC42 plugin", "header.dataChecksum = 0x{0:X8}", header.DataChecksum);
            DicConsole.DebugWriteLine("DC42 plugin", "header.tagChecksum = 0x{0:X8}", header.TagChecksum);
            DicConsole.DebugWriteLine("DC42 plugin", "header.format = 0x{0:X2}", header.Format);
            DicConsole.DebugWriteLine("DC42 plugin", "header.fmtByte = 0x{0:X2}", header.FmtByte);
            DicConsole.DebugWriteLine("DC42 plugin", "header.valid = {0}", header.Valid);
            DicConsole.DebugWriteLine("DC42 plugin", "header.reserved = {0}", header.Reserved);

            if (header.Valid != 1 || header.Reserved != 0)
            {
                return(false);
            }

            // Some versions seem to incorrectly create little endian fields
            if (header.DataSize + header.TagSize + 0x54 != imageFilter.GetDataForkLength() &&
                header.Format != kSigmaFormatTwiggy)
            {
                header.DataSize     = BitConverter.ToUInt32(buffer, 0x40);
                header.TagSize      = BitConverter.ToUInt32(buffer, 0x44);
                header.DataChecksum = BitConverter.ToUInt32(buffer, 0x48);
                header.TagChecksum  = BitConverter.ToUInt32(buffer, 0x4C);

                if (header.DataSize + header.TagSize + 0x54 != imageFilter.GetDataForkLength() &&
                    header.Format != kSigmaFormatTwiggy)
                {
                    return(false);
                }
            }

            if (header.Format != kSonyFormat400K && header.Format != kSonyFormat800K &&
                header.Format != kSonyFormat720K && header.Format != kSonyFormat1440K &&
                header.Format != kSonyFormat1680K && header.Format != kSigmaFormatTwiggy &&
                header.Format != kNotStandardFormat)
            {
                DicConsole.DebugWriteLine("DC42 plugin", "Unknown header.format = 0x{0:X2} value", header.Format);

                return(false);
            }

            if (header.FmtByte != kSonyFmtByte400K && header.FmtByte != kSonyFmtByte800K &&
                header.FmtByte != kSonyFmtByte800KIncorrect && header.FmtByte != kSonyFmtByteProDos &&
                header.FmtByte != kInvalidFmtByte && header.FmtByte != kSigmaFmtByteTwiggy &&
                header.FmtByte != kFmtNotStandard && header.FmtByte != kMacOSXFmtByte)
            {
                DicConsole.DebugWriteLine("DC42 plugin", "Unknown tmp_header.fmtByte = 0x{0:X2} value", header.FmtByte);

                return(false);
            }

            if (header.FmtByte == kInvalidFmtByte)
            {
                DicConsole.DebugWriteLine("DC42 plugin", "Image says it's unformatted");

                return(false);
            }

            dataOffset           = 0x54;
            tagOffset            = header.TagSize != 0 ? 0x54 + header.DataSize : 0;
            imageInfo.SectorSize = 512;
            bptag           = (uint)(header.TagSize != 0 ? 12 : 0);
            dc42ImageFilter = imageFilter;

            imageInfo.Sectors = header.DataSize / 512;

            if (header.TagSize != 0)
            {
                bptag = (uint)(header.TagSize / imageInfo.Sectors);
                DicConsole.DebugWriteLine("DC42 plugin", "bptag = {0} bytes", bptag);

                if (bptag != 12 && bptag != 20 && bptag != 24)
                {
                    DicConsole.DebugWriteLine("DC42 plugin", "Unknown tag size");
                    return(false);
                }

                imageInfo.ReadableSectorTags.Add(SectorTagType.AppleSectorTag);
            }

            imageInfo.ImageSize            = imageInfo.Sectors * imageInfo.SectorSize + imageInfo.Sectors * bptag;
            imageInfo.CreationTime         = imageFilter.GetCreationTime();
            imageInfo.LastModificationTime = imageFilter.GetLastWriteTime();
            imageInfo.MediaTitle           = header.DiskName;

            switch (header.Format)
            {
            case kSonyFormat400K:
                imageInfo.MediaType = imageInfo.Sectors == 1600 ? MediaType.AppleSonyDS : MediaType.AppleSonySS;
                break;

            case kSonyFormat800K:
                imageInfo.MediaType = MediaType.AppleSonyDS;
                break;

            case kSonyFormat720K:
                imageInfo.MediaType = MediaType.DOS_35_DS_DD_9;
                break;

            case kSonyFormat1440K:
                imageInfo.MediaType = MediaType.DOS_35_HD;
                break;

            case kSonyFormat1680K:
                imageInfo.MediaType = MediaType.DMF;
                break;

            case kSigmaFormatTwiggy:
                imageInfo.MediaType = MediaType.AppleFileWare;
                break;

            case kNotStandardFormat:
                switch (imageInfo.Sectors)
                {
                case 9728:
                    imageInfo.MediaType = MediaType.AppleProfile;
                    break;

                case 19456:
                    imageInfo.MediaType = MediaType.AppleProfile;
                    break;

                case 38912:
                    imageInfo.MediaType = MediaType.AppleWidget;
                    break;

                case 39040:
                    imageInfo.MediaType = MediaType.AppleHD20;
                    break;

                default:
                    imageInfo.MediaType = MediaType.Unknown;
                    break;
                }

                break;

            default:
                imageInfo.MediaType = MediaType.Unknown;
                break;
            }

            if (imageInfo.MediaType == MediaType.AppleFileWare)
            {
                byte[] data = new byte[header.DataSize];
                byte[] tags = new byte[header.TagSize];

                twiggyCache     = new byte[header.DataSize];
                twiggyCacheTags = new byte[header.TagSize];
                twiggy          = true;

                Stream datastream = imageFilter.GetDataForkStream();
                datastream.Seek(dataOffset, SeekOrigin.Begin);
                datastream.Read(data, 0, (int)header.DataSize);

                Stream tagstream = imageFilter.GetDataForkStream();
                tagstream.Seek(tagOffset, SeekOrigin.Begin);
                tagstream.Read(tags, 0, (int)header.TagSize);

                ushort mfsMagic     = BigEndianBitConverter.ToUInt16(data, data.Length / 2 + 0x400);
                ushort mfsAllBlocks = BigEndianBitConverter.ToUInt16(data, data.Length / 2 + 0x412);

                // Detect a Macintosh Twiggy
                if (mfsMagic == 0xD2D7 && mfsAllBlocks == 422)
                {
                    DicConsole.DebugWriteLine("DC42 plugin", "Macintosh Twiggy detected, reversing disk sides");
                    Array.Copy(data, header.DataSize / 2, twiggyCache, 0, header.DataSize / 2);
                    Array.Copy(tags, header.TagSize / 2, twiggyCacheTags, 0, header.TagSize / 2);
                    Array.Copy(data, 0, twiggyCache, header.DataSize / 2, header.DataSize / 2);
                    Array.Copy(tags, 0, twiggyCacheTags, header.TagSize / 2, header.TagSize / 2);
                }
                else
                {
                    DicConsole.DebugWriteLine("DC42 plugin", "Lisa Twiggy detected, reversing second half of disk");
                    Array.Copy(data, 0, twiggyCache, 0, header.DataSize / 2);
                    Array.Copy(tags, 0, twiggyCacheTags, 0, header.TagSize / 2);

                    int copiedSectors = 0;
                    int sectorsToCopy = 0;

                    for (int i = 0; i < 46; i++)
                    {
                        if (i >= 0 && i <= 3)
                        {
                            sectorsToCopy = 22;
                        }
                        if (i >= 4 && i <= 10)
                        {
                            sectorsToCopy = 21;
                        }
                        if (i >= 11 && i <= 16)
                        {
                            sectorsToCopy = 20;
                        }
                        if (i >= 17 && i <= 22)
                        {
                            sectorsToCopy = 19;
                        }
                        if (i >= 23 && i <= 28)
                        {
                            sectorsToCopy = 18;
                        }
                        if (i >= 29 && i <= 34)
                        {
                            sectorsToCopy = 17;
                        }
                        if (i >= 35 && i <= 41)
                        {
                            sectorsToCopy = 16;
                        }
                        if (i >= 42 && i <= 45)
                        {
                            sectorsToCopy = 15;
                        }

                        Array.Copy(data, header.DataSize / 2 + copiedSectors * 512, twiggyCache,
                                   twiggyCache.Length - copiedSectors * 512 - sectorsToCopy * 512, sectorsToCopy * 512);
                        Array.Copy(tags, header.TagSize / 2 + copiedSectors * bptag,
                                   twiggyCacheTags,
                                   twiggyCacheTags.Length - copiedSectors * bptag - sectorsToCopy * bptag,
                                   sectorsToCopy * bptag);

                        copiedSectors += sectorsToCopy;
                    }
                }
            }

            try
            {
                if (imageFilter.HasResourceFork())
                {
                    ResourceFork rsrcFork = new ResourceFork(imageFilter.GetResourceForkStream());
                    if (rsrcFork.ContainsKey(0x76657273))
                    {
                        Resource versRsrc = rsrcFork.GetResource(0x76657273);

                        byte[] vers = versRsrc?.GetResource(versRsrc.GetIds()[0]);

                        if (vers != null)
                        {
                            Version version = new Version(vers);

                            string release = null;
                            string dev     = null;
                            string pre     = null;

                            string major = $"{version.MajorVersion}";
                            string minor = $".{version.MinorVersion / 10}";
                            if (version.MinorVersion % 10 > 0)
                            {
                                release = $".{version.MinorVersion % 10}";
                            }
                            switch (version.DevStage)
                            {
                            case Version.DevelopmentStage.Alpha:
                                dev = "a";
                                break;

                            case Version.DevelopmentStage.Beta:
                                dev = "b";
                                break;

                            case Version.DevelopmentStage.PreAlpha:
                                dev = "d";
                                break;
                            }

                            if (dev == null && version.PreReleaseVersion > 0)
                            {
                                dev = "f";
                            }

                            if (dev != null)
                            {
                                pre = $"{version.PreReleaseVersion}";
                            }

                            imageInfo.ApplicationVersion = $"{major}{minor}{release}{dev}{pre}";
                            imageInfo.Application        = version.VersionString;
                            imageInfo.Comments           = version.VersionMessage;
                        }
                    }

                    if (rsrcFork.ContainsKey(0x64437079))
                    {
                        Resource dCpyRsrc = rsrcFork.GetResource(0x64437079);
                        if (dCpyRsrc != null)
                        {
                            string dCpy = StringHandlers.PascalToString(dCpyRsrc.GetResource(dCpyRsrc.GetIds()[0]),
                                                                        Encoding.GetEncoding("macintosh"));
                            Regex dCpyEx    = new Regex(REGEX_DCPY);
                            Match dCpyMatch = dCpyEx.Match(dCpy);

                            if (dCpyMatch.Success)
                            {
                                imageInfo.Application        = dCpyMatch.Groups["application"].Value;
                                imageInfo.ApplicationVersion = dCpyMatch.Groups["version"].Value;
                            }
                        }
                    }
                }
            }
            catch (InvalidCastException) { }

            DicConsole.DebugWriteLine("DC42 plugin", "Image application = {0} version {1}", imageInfo.Application,
                                      imageInfo.ApplicationVersion);

            imageInfo.XmlMediaType = XmlMediaType.BlockMedia;
            DicConsole.VerboseWriteLine("DiskCopy 4.2 image contains a disk of type {0}", imageInfo.MediaType);

            switch (imageInfo.MediaType)
            {
            case MediaType.AppleSonySS:
                imageInfo.Cylinders       = 80;
                imageInfo.Heads           = 1;
                imageInfo.SectorsPerTrack = 10;
                break;

            case MediaType.AppleSonyDS:
                imageInfo.Cylinders       = 80;
                imageInfo.Heads           = 2;
                imageInfo.SectorsPerTrack = 10;
                break;

            case MediaType.DOS_35_DS_DD_9:
                imageInfo.Cylinders       = 80;
                imageInfo.Heads           = 2;
                imageInfo.SectorsPerTrack = 9;
                break;

            case MediaType.DOS_35_HD:
                imageInfo.Cylinders       = 80;
                imageInfo.Heads           = 2;
                imageInfo.SectorsPerTrack = 18;
                break;

            case MediaType.DMF:
                imageInfo.Cylinders       = 80;
                imageInfo.Heads           = 2;
                imageInfo.SectorsPerTrack = 21;
                break;

            case MediaType.AppleProfile:
                switch (imageInfo.Sectors)
                {
                case 9728:
                    imageInfo.Cylinders = 152;
                    break;

                case 19456:
                    imageInfo.Cylinders = 304;
                    break;
                }

                imageInfo.Heads           = 4;
                imageInfo.SectorsPerTrack = 16;
                break;

            case MediaType.AppleWidget:
                imageInfo.Cylinders       = 608;
                imageInfo.Heads           = 2;
                imageInfo.SectorsPerTrack = 16;
                break;

            case MediaType.AppleHD20:
                imageInfo.Cylinders       = 610;
                imageInfo.Heads           = 2;
                imageInfo.SectorsPerTrack = 16;
                break;

            default:
                imageInfo.Cylinders       = (uint)(imageInfo.Sectors / 16 / 63);
                imageInfo.Heads           = 16;
                imageInfo.SectorsPerTrack = 63;
                break;
            }

            return(true);
        }
Пример #60
0
        public FlvWriter(Stream stream, bool append)
        {
            _writer = new AMFWriter(stream);
            _append = append;
            if (_append)
            {
                if (stream.Length > 9 + 15)
                {
                    try
                    {
                        //Skip header
                        stream.Position = 9;
                        byte[] tagBuffer = new byte[15];
                        //previousTagSize
                        stream.Read(tagBuffer, 0, 4);
                        //start of flv tag
                        byte dataType = (byte)stream.ReadByte();
                        if (dataType == IOConstants.TYPE_METADATA)
                        {
                            _metaPosition = stream.Position - 1;
                            //body size
                            stream.Read(tagBuffer, 5, 3);
                            int bodySize = tagBuffer[5] << 16 | tagBuffer[6] << 8 | tagBuffer[7];
                            //timestamp
                            stream.Read(tagBuffer, 8, 4);
                            //streamid
                            stream.Read(tagBuffer, 12, 3);
                            byte[] buffer = new byte[bodySize];
                            stream.Read(buffer, 0, buffer.Length);
                            MemoryStream ms         = new MemoryStream(buffer);
                            AMFReader    input      = new AMFReader(ms);
                            string       onMetaData = input.ReadData() as string;//input.ReadString();
                            IDictionary  properties = input.ReadData() as IDictionary;
                            if (properties.Contains("duration"))
                            {
                                _duration = System.Convert.ToInt32(properties["duration"]);
                            }
                            else
                            {
#if !SILVERLIGHT
                                log.Warn("Could not read Flv duration from metadata");
#endif
                            }
                        }
                        else
                        {
#if !SILVERLIGHT
                            log.Warn("Could not read Flv duration");
#endif
                        }
                    }
                    catch (Exception ex)
                    {
#if !SILVERLIGHT
                        log.Warn("Error reading Flv duration", ex);
#endif
                    }
                }
                stream.Seek(0, SeekOrigin.End);//Appending
            }
        }