tarinputstream.cs

来自「全功能c#编译器」· CS 代码 · 共 683 行 · 第 1/2 页

		{
			int numToSkip = this.entrySize - this.entryOffset;
			
			if (this.debug) {
				//Console.WriteLine.WriteLine("TarInputStream: SKIP currENTRY '" + this.currEntry.Name + "' SZ " + this.entrySize + " OFF " + this.entryOffset + "  skipping " + numToSkip + " bytes");
			}
			
			if (numToSkip > 0) {
				this.Skip(numToSkip);
			}
			
			this.readBuf = null;
		}
		
		/// <summary>
		/// Get the next entry in this tar archive. This will skip
		/// over any remaining data in the current entry, if there
		/// is one, and place the input stream at the header of the
		/// next entry, and read the header and instantiate a new
		/// TarEntry from the header bytes and return that entry.
		/// If there are no more entries in the archive, null will
		/// be returned to indicate that the end of the archive has
		/// been reached.
		/// </summary>
		/// <returns>
		/// The next TarEntry in the archive, or null.
		/// </returns>
		public TarEntry GetNextEntry()
		{
			if (this.hasHitEOF) {
				return null;
			}
			
			if (this.currEntry != null) {
				SkipToNextEntry();
			}
			
			byte[] headerBuf = this.buffer.ReadBlock();
			
			if (headerBuf == null) {
				if (this.debug) {
					//Console.WriteLine.WriteLine("READ NULL BLOCK");
				}
				
				this.hasHitEOF = true;
			} else if (this.buffer.IsEOFBlock(headerBuf)) {
				if (this.debug) {
					//Console.WriteLine.WriteLine( "READ EOF BLOCK" );
				}
				
				this.hasHitEOF = true;
			}
			
			if (this.hasHitEOF) {
				this.currEntry = null;
			} else {
				try {
					TarHeader header = new TarHeader();
					header.ParseBuffer(headerBuf);
					this.entryOffset = 0;
					this.entrySize = (int)header.size;
					
					StringBuilder longName = null;
					
					if (header.typeFlag == TarHeader.LF_GNU_LONGNAME) {
						
						byte[] nameBuffer = new byte[TarBuffer.BlockSize];
						
						int numToRead = this.entrySize;
						
						longName = new StringBuilder();
						
						while (numToRead > 0) {
							int numRead = this.Read(nameBuffer, 0, (numToRead > nameBuffer.Length ? nameBuffer.Length : numToRead));
							
							if (numRead == -1) {
								throw new InvalidHeaderException("Failed to read long name entry");
							}
							
							longName.Append(TarHeader.ParseName(nameBuffer, 0, numRead).ToString());
							numToRead -= numRead;
						}
						
						SkipToNextEntry();
						headerBuf = this.buffer.ReadBlock();
					} else if (header.typeFlag == TarHeader.LF_GHDR) {  // POSIX global extended header 
						// Ignore things we dont understand completely for now
						SkipToNextEntry();
						headerBuf = this.buffer.ReadBlock();
					} else if (header.typeFlag == TarHeader.LF_XHDR) {  // POSIX extended header
						// Ignore things we dont understand completely for now
						SkipToNextEntry();
						headerBuf = this.buffer.ReadBlock();
					} else if (header.typeFlag == TarHeader.LF_GNU_VOLHDR) {
						// TODO  could show volume name when verbose?
						SkipToNextEntry();
						headerBuf = this.buffer.ReadBlock();
					} else if (header.typeFlag != TarHeader.LF_NORMAL && 
					           header.typeFlag != TarHeader.LF_OLDNORM &&
					           header.typeFlag != TarHeader.LF_DIR) {
						// Ignore things we dont understand completely for now
						SkipToNextEntry();
						headerBuf = this.buffer.ReadBlock();
					}
					
					if (this.eFactory == null) {
						this.currEntry = new TarEntry(headerBuf);
						if (longName != null) {
							this.currEntry.TarHeader.name.Length = 0;
							this.currEntry.TarHeader.name.Append(longName.ToString());
						}
					} else {
						this.currEntry = this.eFactory.CreateEntry(headerBuf);
					}
					
					// TODO  ustar is not the only magic possible by any means
					// tar, xtar, ...
					if (!(headerBuf[257] == 'u' && headerBuf[258] == 's' && headerBuf[259] == 't' && headerBuf[260] == 'a' && headerBuf[261] == 'r')) {
						throw new InvalidHeaderException("header magic is not 'ustar', but '" + headerBuf[257] + headerBuf[258] + headerBuf[259] + headerBuf[260] + headerBuf[261] +
						                                 "', or (dec) " + ((int)headerBuf[257]) + ", " + ((int)headerBuf[258]) + ", " + ((int)headerBuf[259]) + ", " + ((int)headerBuf[260]) + ", " + ((int)headerBuf[261]));
					}
					
					if (this.debug) {
						//Console.WriteLine.WriteLine("TarInputStream: SET CURRENTRY '" + this.currEntry.Name + "' size = " + this.currEntry.Size);
					}
					
					this.entryOffset = 0;
					
					// TODO  Review How do we resolve this discrepancy?!
					this.entrySize = (int) this.currEntry.Size;
				} catch (InvalidHeaderException ex) {
					this.entrySize = 0;
					this.entryOffset = 0;
					this.currEntry = null;
					throw new InvalidHeaderException("bad header in record " + this.buffer.GetCurrentBlockNum() + " block " + this.buffer.GetCurrentBlockNum() + ", " + ex.Message);
				}
			}
			return this.currEntry;
		}
		
		/// <summary>
		/// Reads a byte from the current tar archive entry.
		/// This method simply calls read(byte[], int, int).
		/// </summary>
		public override int ReadByte()
		{
			byte[] oneByteBuffer = new byte[1];
			int num = this.Read(oneByteBuffer, 0, 1);
			if (num <= 0) { // return -1 to indicate that no byte was read.
				return -1;
			}
			return (int)oneByteBuffer[0];
		}
		
		/// <summary>
		/// Reads bytes from the current tar archive entry.
		/// 
		/// This method is aware of the boundaries of the current
		/// entry in the archive and will deal with them appropriately
		/// </summary>
		/// <param name="outputBuffer">
		/// The buffer into which to place bytes read.
		/// </param>
		/// <param name="offset">
		/// The offset at which to place bytes read.
		/// </param>
		/// <param name="numToRead">
		/// The number of bytes to read.
		/// </param>
		/// <returns>
		/// The number of bytes read, or 0 at end of stream/EOF.
		/// </returns>
		public override int Read(byte[] outputBuffer, int offset, int numToRead)
		{
			int totalRead = 0;
			
			if (this.entryOffset >= this.entrySize) {
				return 0;
			}
			
			if ((numToRead + this.entryOffset) > this.entrySize) {
				numToRead = this.entrySize - this.entryOffset;
			}
			
			if (this.readBuf != null) {
				int sz = (numToRead > this.readBuf.Length) ? this.readBuf.Length : numToRead;
				
				Array.Copy(this.readBuf, 0, outputBuffer, offset, sz);
				
				if (sz >= this.readBuf.Length) {
					this.readBuf = null;
				} else {
					int newLen = this.readBuf.Length - sz;
					byte[] newBuf = new byte[newLen];
					Array.Copy(this.readBuf, sz, newBuf, 0, newLen);
					this.readBuf = newBuf;
				}
				
				totalRead += sz;
				numToRead -= sz;
				offset += sz;
			}
			
			while (numToRead > 0) {
				byte[] rec = this.buffer.ReadBlock();
				if (rec == null) {
					// Unexpected EOF!
					throw new TarException("unexpected EOF with " + numToRead + " bytes unread");
				}
				
				int sz     = numToRead;
				int recLen = rec.Length;
				
				if (recLen > sz) {
					Array.Copy(rec, 0, outputBuffer, offset, sz);
					this.readBuf = new byte[recLen - sz];
					Array.Copy(rec, sz, this.readBuf, 0, recLen - sz);
				} else {
					sz = recLen;
					Array.Copy(rec, 0, outputBuffer, offset, recLen);
				}
				
				totalRead += sz;
				numToRead -= sz;
				offset += sz;
			}
			
			this.entryOffset += totalRead;
			
			return totalRead;
		}
		
		/// <summary>
		/// Copies the contents of the current tar archive entry directly into
		/// an output stream.
		/// </summary>
		/// <param name="outputStream">
		/// The OutputStream into which to write the entry's data.
		/// </param>
		public void CopyEntryContents(Stream outputStream)
		{
			byte[] buf = new byte[32 * 1024];
			
			while (true) {
				int numRead = this.Read(buf, 0, buf.Length);
				if (numRead <= 0) {
					break;
				}
				outputStream.Write(buf, 0, numRead);
			}
		}
		
		/// <summary>
		/// This interface is provided, along with the method setEntryFactory(), to allow
		/// the programmer to have their own TarEntry subclass instantiated for the
		/// entries return from getNextEntry().
		/// </summary>
		public interface IEntryFactory
		{
			/// <summary>
			/// Create an entry based on name alone
			/// </summary>
			/// <param name="name">
			/// Name of the new EntryPointNotFoundException to create
			/// </param>
			/// <returns>created TarEntry or descendant class</returns>
			TarEntry CreateEntry(string name);
			
			/// <summary>
			/// Create an instance based on an actual file
			/// </summary>
			/// <param name="fileName">
			/// Name of file to represent in the entry
			/// </param>
			/// <returns>
			/// Created TarEntry or descendant class
			/// </returns>
			TarEntry CreateEntryFromFile(string fileName);
			
			/// <summary>
			/// Create a tar entry based on the header information passed
			/// </summary>
			/// <param name="headerBuf">
			/// Buffer containing header information to base entry on
			/// </param>
			/// <returns>
			/// Created TarEntry or descendant class
			/// </returns>
			TarEntry CreateEntry(byte[] headerBuf);
		}

		/// <summary>
		/// Standard entry factory class creating instances of the class TarEntry
		/// </summary>
		public class EntryFactoryAdapter : IEntryFactory
		{
			/// <summary>
			/// Create a TarEntry based on named
			/// </summary>
			public TarEntry CreateEntry(string name)
			{
				return TarEntry.CreateTarEntry(name);
			}
			
			/// <summary>
			/// Create a tar entry with details obtained from <paramref name="fileName">file</paramref>
			/// </summary>
			public TarEntry CreateEntryFromFile(string fileName)
			{
				return TarEntry.CreateEntryFromFile(fileName);
			}

			/// <summary>
			/// Create and entry based on details in <paramref name="headerBuf">header</paramref>
			/// </summary>			
			public TarEntry CreateEntry(byte[] headerBuf)
			{
				return new TarEntry(headerBuf);
			}
		}
	}
	
	
}

/* The original Java file had this header:
	** Authored by Timothy Gerard Endres
	** <mailto:[e-mail]>  <http://www.trustice.com>
	**
	** This work has been placed into the public domain.
	** You may use this work in any way and for any purpose you wish.
	**
	** THIS SOFTWARE IS PROVIDED AS-IS WITHOUT WARRANTY OF ANY KIND,
	** NOT EVEN THE IMPLIED WARRANTY OF MERCHANTABILITY. THE AUTHOR
	** OF THIS SOFTWARE, ASSUMES _NO_ RESPONSIBILITY FOR ANY
	** CONSEQUENCE RESULTING FROM THE USE, MODIFICATION, OR
	** REDISTRIBUTION OF THIS SOFTWARE.
	**
	*/