/** * Constructs a type froma stream * * @param inputStream An input stream * @param indexEntry The index informations * @return The size of the read data * @throws IOException if an I/O error occurs. */ public static INT8 readFromStream(java.io.DataInputStream inputStream, IndexEntry indexEntry) {//throws IOException { if (indexEntry.getType() != RPMIndexType.INT8) { throw new java.lang.IllegalArgumentException("Type <" + indexEntry.getType() + "> does not match <" + RPMIndexType.INT8 + ">"); } byte[] data = new byte[(int)indexEntry.getCount()]; for (int pos = 0; pos < indexEntry.getCount(); pos++) { data[pos] = inputStream.readByte(); } INT8 int8Object = new INT8(data); if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer(int8Object.toString()); } // int8Object.size = indexEntry.getType().getSize() // * indexEntry.getCount(); return(int8Object); }
/** * Constructs a IndexEntry out of a InputStream. This will read the tag id, * the data type, the offset of the data and the number of elements of * data. Note that the number of elements varies in its meaning depending * on the data type. * * @param inputStream An InputStream containing a rpm file. * @throws IOException If an error occurs during reading from stream */ public IndexEntry(java.io.DataInputStream inputStream) {//throws IOException { tag = inputStream.readInt(); if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("tag:" + tag); } type = RPMIndexType.getRPMIndexType(inputStream.readInt()); if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("type: " + type); } offset = inputStream.readInt(); if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("offset: " + offset); } count = inputStream.readInt(); if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("count: " + count); } check(!type.equals(RPMIndexType.UNKNOWN)); }
/** * Constructs a type froma stream * * @param inputStream An input stream * @param indexEntry The index informations * @param length the length of the data * @return The size of the read data * @throws IOException if an I/O error occurs. */ public static I18NSTRING readFromStream(java.io.DataInputStream inputStream, IndexEntry indexEntry, long length) {//throws IOException { if (indexEntry.getType() != RPMIndexType.I18NSTRING) { throw new java.lang.IllegalArgumentException("Type <" + indexEntry.getType() + "> does not match <" + RPMIndexType.I18NSTRING + ">"); } // initialize temporary space for data byte[] stringData = new byte[(int)length]; // and read it from stream inputStream.readFully(stringData); String[] data = new String[(int)indexEntry.getCount()]; int off = 0; for (int pos = 0; pos < indexEntry.getCount(); pos++) { data[pos] = RPMUtil.cArrayToString(stringData, off); // offset for new string is stringlength + 1 for the \0 in c // strings if (data[pos].length() == 0) { off += data[pos].length(); } else { off += (data[pos].length() + 1); } if (off > stringData.Length) { throw new java.lang.IllegalStateException( "Index wrong; Strings doesn't fit into data area. [" + off + ", " + stringData.Length + "]"); } } I18NSTRING stringObject = new I18NSTRING(data); if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer(stringObject.toString()); if (stringObject.size != stringData.Length) { logger.warning("STRING size differs (is:" + stringData.Length + ";should:" + stringObject.size + ")"); } } stringObject.size = stringData.Length; return(stringObject); }
/** * This method creates a rpm data type out of a input stream and an * IndexEntry. The object must at the current position of the input stream. * The length is only needed for string objects; the string objects will * read length bytes of the input stream and will try to convert the data * into a rpm data type. * * @param inputStream * The input stream * @param indexEntry * The IndexEntry that should be read * @param length * The number of bytes to read for string objects * * @return One of the rpm data types coresponding with the type contained in * the IndexEntry. * * @throws IOException * if something was wrong during reading of the input stream */ public static DataTypeIf createFromStream( java.io.DataInputStream inputStream, IndexEntry indexEntry, long length) {//throws IOException { DataTypeIf ret = null; switch ((int)indexEntry.getType().getId()) { case RPMIndexType._NULL: ret = NULL.readFromStream(indexEntry); break; case RPMIndexType._CHAR: ret = CHAR.readFromStream(inputStream, indexEntry); break; case RPMIndexType._INT8: ret = INT8.readFromStream(inputStream, indexEntry); break; case RPMIndexType._INT16: ret = INT16.readFromStream(inputStream, indexEntry); break; case RPMIndexType._INT32: ret = INT32.readFromStream(inputStream, indexEntry); break; case RPMIndexType._INT64: ret = INT64.readFromStream(inputStream, indexEntry); break; case RPMIndexType._STRING: ret = STRING.readFromStream(inputStream, indexEntry, length); break; case RPMIndexType._BIN: ret = BIN.readFromStream(inputStream, indexEntry); break; case RPMIndexType._STRING_ARRAY: ret = STRING_ARRAY.readFromStream(inputStream, indexEntry, length); break; case RPMIndexType._I18NSTRING: ret = I18NSTRING.readFromStream(inputStream, indexEntry, length); break; default: // TODO: UNKNOWN break; } return(ret); }
/** * Creates a new RPMSignature object from an input stream * * @param inputStream * The input stream * @throws IOException * if an error occurs on reading informations out of the * stream */ public RPMSignature(java.io.DataInputStream inputStream, Store store) ://throws IOException { base(inputStream, store) { // Make signature size modulo 8 = 0 long fill = (size % 8L); if (fill != 0) { fill = 8 - fill; } if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("skip " + fill + " bytes for signature"); } size += inputStream.skip(fill); }
/** * Constructs a type froma stream * * @param inputStream An input stream * @param indexEntry The index informations * @param length the length of the data * @return The size of the read data * @throws IOException if an I/O error occurs. */ public static STRING readFromStream(java.io.DataInputStream inputStream, IndexEntry indexEntry, long length) {//throws IOException { if (indexEntry.getType() != RPMIndexType.STRING) { throw new java.lang.IllegalArgumentException("Type <" + indexEntry.getType() + "> does not match <" + RPMIndexType.STRING + ">"); } if (indexEntry.getCount() != 1) { throw new java.lang.IllegalArgumentException( "There can be only one string per tag of type STRING"); } // initialize temporary space for data byte[] stringData = new byte[(int)length]; // and read it from stream inputStream.readFully(stringData); String str = RPMUtil.cArrayToString(stringData, 0); STRING stringObject = new STRING(str); if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer(stringObject.toString()); if (stringObject.size != stringData.Length) { logger.warning("STRING size differs (is:" + stringData.Length + ";should:" + stringObject.size + ")"); } } stringObject.size = stringData.Length; return(stringObject); }
/** * Create a header structure from an input stream. <p/> The header * structure of a signature or a header can be read and also the index * entries containing the tags for this rpm section (signature or * header). <p/> Unless we have a raw header from headerUnload or the * database, a header is read consisting of the following fields: * <code><pre> * byte magic[3]; (3 byte) (8e ad e8) * int version; (1 byte) * byte reserved[4]; (4 byte) * long num_index; (4 byte) * long num_data; (4 byte) * </pre></code> <p/> Afterwards the index entries are read and then the tags * and the correspondig data entries are read. * * @param inputStream * An inputstream containing rpm file informations * @param rawHeader * Are we a raw header (from headerUnload or rpmdb) * @throws IOException * if an error occurs on reading informations out of the * stream */ public Header(java.io.DataInputStream inputStream, bool rawHeader, Store store) {//throws IOException { this.store = store; if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("Start Reading Header"); } if (!rawHeader) { // Read header size = HEADER_LENGTH; int magic = 0; do { magic = inputStream.readUnsignedByte(); if (magic == 0) { inputStream.skip(7); } } while (magic == 0); check(magic == 0x8E, "Header magic 0x" + java.lang.Integer.toHexString(magic) + " != 0x8E"); magic = inputStream.readUnsignedByte(); check(magic == 0xAD, "Header magic 0x" + java.lang.Integer.toHexString(magic) + " != 0xAD"); magic = inputStream.readUnsignedByte(); check(magic == 0xE8, "Header magic 0x" + java.lang.Integer.toHexString(magic) + " != 0xE8"); version = inputStream.readUnsignedByte(); if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("version: " + version); } // skip reserved bytes inputStream.skipBytes(4); } indexNumber = inputStream.readInt(); if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("indexes available: " + indexNumber); } indexDataSize = inputStream.readInt(); if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("index data size: " + indexDataSize); } // Read indexes // make sure to sort them in order of offset to // be able to read the store without jumping arround in // the file java.util.TreeSet <IndexEntry> _indexes = new java.util.TreeSet <IndexEntry>(new IAC_IndexesComparator()); for (int i = 0; i < this.indexNumber; i++) { IndexEntry index = new IndexEntry(inputStream); _indexes.add(index); size += index.getSize(); } indexes = new IndexEntry[0]; indexes = (IndexEntry[])_indexes.toArray(indexes); // Read store for (int i = 0; i < indexes.Length; i++) { IndexEntry index = indexes[i]; // if (index.getType().equals(RPMIndexType.STRING_ARRAY) || // index.getType().equals(RPMIndexType.STRING) || // index.getType().equals(RPMIndexType.I18NSTRING)) { // if (i < (indexes.length - 1)) { // IndexEntry next = indexes[i + 1]; // // length = next.getOffset() - index.getOffset(); // } else { // length = indexDataSize - index.getOffset(); // } // // // and initialize temporary space for data // stringData = new byte[(int) length]; // // // and read it from stream // inputStream.readFully(stringData); // } DataTypeIf dataObject = null; if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("Reading for tag '" + store.getTagNameForId(index.getTag()) + "' '" + index.getCount() + "' entries of type '" + index.getType().getName() + "'"); } dataObject = TypeFactory .createFromStream(inputStream, index, (i < (indexes.Length - 1)) ? (indexes[i + 1] .getOffset() - index.getOffset()) : (indexDataSize - index.getOffset())); // adjust size size += dataObject.getSize(); store.setTag(index.getTag(), dataObject); } if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer(""); } if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("Finished Reading Header"); } }
/** * Construct a header structure for the given input stream. * * @param inputStream * @throws IOException */ public Header(java.io.DataInputStream inputStream, Store store) :// throws IOException { this(inputStream, false, store) { }
public RPMHeader(java.io.DataInputStream inputStream, bool raw, Store store) ://throws IOException { base(inputStream, raw, store) { }
/** * Read informations of a rpm file out of an input stream. * * @param rpmInputStream The input stream representing the rpm file * @throws IOException if an error occurs during read of the rpm file */ private void readFromStream(java.io.InputStream rpmInputStream) {//throws IOException { ByteCountInputStream allCountInputStream = new ByteCountInputStream( rpmInputStream); java.io.InputStream inputStream = new java.io.DataInputStream(allCountInputStream); lead = new RPMLead((java.io.DataInputStream)inputStream); signature = new RPMSignature((java.io.DataInputStream)inputStream, store); if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("Signature Size: " + signature.getSize()); } header = new RPMHeader((java.io.DataInputStream)inputStream, store); if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("Header Size: " + header.getSize()); } DataTypeIf payloadTag = getTag("PAYLOADFORMAT"); String payloadFormat = payloadTag != null?payloadTag.toString() : "cpio"; DataTypeIf payloadCompressionTag = getTag("PAYLOADCOMPRESSOR"); String payloadCompressor = payloadCompressionTag != null?payloadCompressionTag .toString() : "gzip"; if (payloadFormat.equals("cpio")) { if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("PAYLOADCOMPRESSOR: " + payloadCompressor); } if (payloadCompressor.equals("gzip")) { inputStream = new GzipCompressorInputStream(allCountInputStream); } else if (payloadCompressor.equals("bzip2")) { inputStream = new BZip2CompressorInputStream(allCountInputStream); } else if (payloadCompressor.equals("lzma")) { try { java.io.PipedOutputStream pout = new java.io.PipedOutputStream(); inputStream = new java.io.PipedInputStream(pout); byte[] properties = new byte[5]; if (allCountInputStream.read(properties, 0, 5) != 5) { throw (new java.io.IOException("input .lzma is too short")); } SevenZip.Compression.LZMA.Decoder decoder = new SevenZip.Compression.LZMA.Decoder(); decoder.SetDecoderProperties(properties); long outSize = 0; for (int i = 0; i < 8; i++) { int v = allCountInputStream.read(); if (v < 0) { throw (new java.io.IOException("lzma error : Can't Read 1")); } outSize |= ((long)v) << (8 * i); } if (outSize == -1) { outSize = java.lang.Long.MAX_VALUE; } Decode decoderRunnable = new Decode(decoder, allCountInputStream, pout, outSize); java.lang.Thread t = new java.lang.Thread(decoderRunnable, "LZMA Decoder"); t.start(); } catch (java.lang.NoClassDefFoundError) { String message = "No LZMA library found. Attach p7zip library to classpath (http://p7zip.sourceforge.net/)"; logger.severe(message); throw new java.io.IOException(message); } } else if (payloadCompressor.equals("none")) { inputStream = allCountInputStream; } else { throw new java.io.IOException("Unsupported compressor type " + payloadCompressor); } ByteCountInputStream countInputStream = new ByteCountInputStream(inputStream); CpioArchiveInputStream cpioInputStream = new CpioArchiveInputStream(countInputStream); CpioArchiveEntry readEntry; java.util.List <String> fileNamesList = new java.util.ArrayList <String>(); String fileEntry; while ((readEntry = cpioInputStream.getNextCPIOEntry()) != null) { if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("Read CPIO entry: " + readEntry.getName() + " ;mode:" + readEntry.getMode()); } if (readEntry.isRegularFile() || readEntry.isSymbolicLink() || readEntry.isDirectory()) { fileEntry = readEntry.getName(); if (fileEntry.startsWith("./")) { fileEntry = fileEntry.substring(1); } fileNamesList.add(fileEntry); } } store.setTag("FILENAMES", TypeFactory.createSTRING_ARRAY((String[])fileNamesList.toArray(new String[fileNamesList.size()]))); setHeaderTagFromSignature("ARCHIVESIZE", "PAYLOADSIZE"); // check ARCHIVESIZE with countInputStream.getCount(); Object archiveSizeObject = getTag("ARCHIVESIZE"); if (archiveSizeObject != null) { if (archiveSizeObject is INT32) { int archiveSize = ((INT32)archiveSizeObject).getData()[0]; if (archiveSize != countInputStream.getCount()) { new java.io.IOException("ARCHIVESIZE not correct"); } } } store.setTag("J_ARCHIVESIZE", TypeFactory .createINT64(new long[] { countInputStream.getCount() })); } else { throw new java.io.IOException("Unsupported Payload type " + payloadFormat); } // filling in signatures // TODO: check signatures! setHeaderTagFromSignature("SIGSIZE", "SIZE"); setHeaderTagFromSignature("SIGLEMD5_1", "LEMD5_1"); setHeaderTagFromSignature("SIGPGP", "PGP"); setHeaderTagFromSignature("SIGLEMD5_2", "LEMD5_2"); setHeaderTagFromSignature("SIGMD5", "MD5"); setHeaderTagFromSignature("SIGGPG", "GPG"); setHeaderTagFromSignature("SIGPGP5", "PGP5"); setHeaderTagFromSignature("DSAHEADER", "DSA"); setHeaderTagFromSignature("RSAHEADER", "RSA"); setHeaderTagFromSignature("SHA1HEADER", "SHA1"); store.setTag("J_FILESIZE", TypeFactory .createINT64(new long[] { allCountInputStream.getCount() })); rpmInputStream.close(); }
protected internal RPMLead(java.io.DataInputStream inputStream) {//throws IOException { if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("Start Reading Lead"); } try { int magic = inputStream.readUnsignedByte(); check(magic == 0xED, "Lead magic 0x" + java.lang.Integer.toHexString(magic) + " != 0xED"); magic = inputStream.readUnsignedByte(); check(magic == 0xAB, "Lead magic 0x" + java.lang.Integer.toHexString(magic) + " != 0xAB"); magic = inputStream.readUnsignedByte(); check(magic == 0xEE, "Lead magic 0x" + java.lang.Integer.toHexString(magic) + " != 0xEE"); magic = inputStream.readUnsignedByte(); check(magic == 0xDB, "Lead magic 0x" + java.lang.Integer.toHexString(magic) + " != 0xDB"); major = inputStream.readUnsignedByte(); check(major < 5, "Major Number should be less than 5"); if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("major: " + major); } minor = inputStream.readUnsignedByte(); if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("minor: " + minor); } int uS = inputStream.readUnsignedShort(); //LeadType lt; type = LeadType.getLeadType(uS); //type = LeadType.getLeadType(inputStream.readUnsignedShort()); if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("type: " + type.getName()); } arch = LeadArchitecture.getLeadArchitecture(inputStream.readUnsignedShort()); if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("arch: " + arch.getName()); } byte[] nameBuf = new byte[66]; inputStream.readFully(nameBuf); name = RPMUtil.cArrayToString(nameBuf, 0); if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("name: " + name); } os = LeadOS.getLeadOS(inputStream.readUnsignedShort()); if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("os: " + os.getName()); } sigType = LeadSignature.getLeadSignature(inputStream.readUnsignedShort()); if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("sigType: " + sigType.getName()); } inputStream.skipBytes(16); check(!type.equals(LeadType.UNKNOWN), "Type is not specified"); check(!sigType.equals(LeadType.UNKNOWN), "Signaturetype is not specified"); } finally { if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("Finished Reading Lead"); } } }